@sentry/junior 0.66.3 → 0.67.1

package/dist/{chunk-DG2I6GXC.js → chunk-5UIDU7XR.js}

@@ -8,12 +8,15 @@ import {
   getStateAdapter,
   parseSlackThreadId,
   sandboxSkillDir
-} from "./chunk-SAYCFF7O.js";
+} from "./chunk-MT23VNOH.js";
 import {
+  isActorUserId,
   isRecord,
+  logException,
   logInfo,
-  logWarn
-} from "./chunk-6QWWMZCK.js";
+  logWarn,
+  parseActorUserId
+} from "./chunk-OIIXZOOC.js";
 import {
   sentry_exports
 } from "./chunk-Z3YD6NHK.js";
@@ -23,755 +26,1788 @@ import {
   worldPathCandidates
 } from "./chunk-KVZL5NZS.js";
 
-// src/handlers/health.ts
-function GET() {
-  return Response.json({
-    status: "ok",
-    service: "junior",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  });
+// src/chat/plugins/logging.ts
+function createAgentPluginLogger(plugin) {
+  return {
+    info(message, metadata) {
+      logInfo(
+        "agent_plugin_log_info",
+        {},
+        { "app.plugin.name": plugin, ...metadata },
+        message
+      );
+    },
+    warn(message, metadata) {
+      logWarn(
+        "agent_plugin_log_warn",
+        {},
+        { "app.plugin.name": plugin, ...metadata },
+        message
+      );
+    },
+    error(message, metadata) {
+      logException(
+        new Error(message),
+        "agent_plugin_log_error",
+        {},
+        { "app.plugin.name": plugin, ...metadata },
+        message
+      );
+    }
+  };
 }
 
-// src/chat/prompt.ts
-import fs from "fs";
-import path from "path";
-
-// src/chat/turn-context-tag.ts
-var TURN_CONTEXT_TAG = "runtime-turn-context";
-
-// src/chat/interruption-marker.ts
-var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
-function getInterruptionMarker() {
-  return INTERRUPTED_MARKER;
+// src/chat/plugins/state.ts
+import { createHash } from "crypto";
+var MAX_PLUGIN_STATE_KEY_LENGTH = 512;
+function hashKeyPart(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 32);
 }
-
-// src/chat/slack/status-format.ts
-var SLACK_STATUS_MAX_LENGTH = 50;
-function truncateStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
+function pluginStateKey(plugin, key2) {
+  return `junior:plugin_state:${hashKeyPart(plugin)}:${hashKeyPart(key2)}`;
+}
+function validatePluginStateKey(key2) {
+  if (!key2.trim()) {
+    throw new Error("Plugin state key is required");
   }
-  if (trimmed.length <= SLACK_STATUS_MAX_LENGTH) {
-    return trimmed;
+  if (key2.length > MAX_PLUGIN_STATE_KEY_LENGTH) {
+    throw new Error("Plugin state key exceeds the maximum length");
   }
-  return `${trimmed.slice(0, SLACK_STATUS_MAX_LENGTH - 3).trimEnd()}...`;
 }
-
-// src/chat/slack/mrkdwn.ts
-function ensureBlockSpacing(text) {
-  const codeBlockPattern = /^```/;
-  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
-  const lines = text.split("\n");
-  const result = [];
-  let inCodeBlock = false;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const isCodeFence = codeBlockPattern.test(line.trimStart());
-    if (isCodeFence) {
-      if (!inCodeBlock) {
-        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
-        if (prev2 !== void 0 && prev2.trim() !== "") {
-          result.push("");
-        }
-      }
-      inCodeBlock = !inCodeBlock;
-      result.push(line);
-      continue;
-    }
-    if (inCodeBlock) {
-      result.push(line);
+function legacyStateKey(key2, options) {
+  for (const prefix of options?.legacyStatePrefixes ?? []) {
+    const trimmed = prefix.trim();
+    if (!trimmed) {
       continue;
     }
-    const prev = result.length > 0 ? result[result.length - 1] : void 0;
-    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
-      result.push("");
+    if (key2 === trimmed || key2.startsWith(`${trimmed}:`)) {
+      return key2;
     }
-    result.push(line);
   }
-  return result.join("\n");
-}
-function renderSlackMrkdwn(text) {
-  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
-  normalized = ensureBlockSpacing(normalized);
-  return normalized.replace(/\n{3,}/g, "\n\n").trim();
+  return void 0;
 }
-function normalizeSlackStatusText(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return "";
-  }
-  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+function createPluginState(plugin, options) {
+  return {
+    async delete(key2) {
+      validatePluginStateKey(key2);
+      const state = getStateAdapter();
+      await state.connect();
+      await state.delete(pluginStateKey(plugin, key2));
+      const legacyKey = legacyStateKey(key2, options);
+      if (legacyKey) {
+        await state.delete(legacyKey);
+      }
+    },
+    async get(key2) {
+      validatePluginStateKey(key2);
+      const state = getStateAdapter();
+      await state.connect();
+      const value = await state.get(pluginStateKey(plugin, key2));
+      if (value !== null && value !== void 0) {
+        return value;
+      }
+      const legacyKey = legacyStateKey(key2, options);
+      return legacyKey ? await state.get(legacyKey) ?? void 0 : void 0;
+    },
+    async set(key2, value, ttlMs) {
+      validatePluginStateKey(key2);
+      const state = getStateAdapter();
+      await state.connect();
+      await state.set(pluginStateKey(plugin, key2), value, ttlMs);
+    },
+    async setIfNotExists(key2, value, ttlMs) {
+      validatePluginStateKey(key2);
+      const state = getStateAdapter();
+      await state.connect();
+      const legacyKey = legacyStateKey(key2, options);
+      if (legacyKey) {
+        const existing = await state.get(legacyKey);
+        if (existing !== null && existing !== void 0) {
+          return false;
+        }
+      }
+      return await state.setIfNotExists(
+        pluginStateKey(plugin, key2),
+        value,
+        ttlMs
+      );
+    },
+    async withLock(key2, ttlMs, callback) {
+      validatePluginStateKey(key2);
+      const state = getStateAdapter();
+      await state.connect();
+      const lockKey = legacyStateKey(key2, options) ?? pluginStateKey(plugin, key2);
+      const lock = await state.acquireLock(lockKey, ttlMs);
+      if (!lock) {
+        throw new Error(`Could not acquire plugin state lock for ${key2}`);
+      }
+      try {
+        return await callback();
+      } finally {
+        await state.releaseLock(lock);
+      }
+    }
+  };
 }
 
-// src/chat/slack/output.ts
-var MAX_INLINE_CHARS = 2200;
-var MAX_INLINE_LINES = 45;
-var CONTINUED_MARKER = "\n\n[Continued below]";
-function countSlackLines(text) {
-  if (!text) {
-    return 0;
+// src/chat/credentials/subject.ts
+import { createHmac, timingSafeEqual } from "crypto";
+
+// src/chat/slack/client.ts
+import { WebClient } from "@slack/web-api";
+var SlackActionError = class extends Error {
+  code;
+  apiError;
+  needed;
+  provided;
+  statusCode;
+  requestId;
+  errorData;
+  retryAfterSeconds;
+  detail;
+  detailLine;
+  detailRule;
+  constructor(message, code, options = {}) {
+    super(message);
+    this.name = "SlackActionError";
+    this.code = code;
+    this.apiError = options.apiError;
+    this.needed = options.needed;
+    this.provided = options.provided;
+    this.statusCode = options.statusCode;
+    this.requestId = options.requestId;
+    this.errorData = options.errorData;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+    this.detail = options.detail;
+    this.detailLine = options.detailLine;
+    this.detailRule = options.detailRule;
   }
-  return text.split("\n").length;
-}
-function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-  return text.length <= maxChars && countSlackLines(text) <= maxLines;
-}
-function findSplitIndex(text, maxChars) {
-  if (text.length <= maxChars) {
-    return text.length;
+};
+function serializeSlackErrorData(data) {
+  if (!data || typeof data !== "object") {
+    return void 0;
   }
-  const bounded = text.slice(0, maxChars);
-  const newlineIndex = bounded.lastIndexOf("\n");
-  if (newlineIndex > 0) {
-    return newlineIndex;
+  const filtered = Object.fromEntries(
+    Object.entries(data).filter(
+      ([key2]) => key2 !== "error"
+    )
+  );
+  if (Object.keys(filtered).length === 0) {
+    return void 0;
   }
-  const spaceIndex = bounded.lastIndexOf(" ");
-  if (spaceIndex > 0) {
-    return spaceIndex;
+  try {
+    const serialized = JSON.stringify(filtered);
+    return serialized.length <= 600 ? serialized : `${serialized.slice(0, 597)}...`;
+  } catch {
+    return void 0;
   }
-  return maxChars;
 }
-function splitByLineBudget(text, maxLines) {
-  if (maxLines <= 0) {
-    return "";
+function getHeaderString(headers, name) {
+  if (!headers || typeof headers !== "object") {
+    return void 0;
   }
-  const lines = text.split("\n");
-  if (lines.length <= maxLines) {
-    return text;
+  const key2 = name.toLowerCase();
+  const entries = headers;
+  for (const [entryKey, value] of Object.entries(entries)) {
+    if (entryKey.toLowerCase() !== key2) continue;
+    if (typeof value === "string") return value;
+    if (Array.isArray(value)) {
+      const first = value.find((entry) => typeof entry === "string");
+      return typeof first === "string" ? first : void 0;
+    }
   }
-  return lines.slice(0, maxLines).join("\n");
-}
-function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
-  return {
-    maxChars: Math.max(1, maxChars - suffix.length),
-    maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
-  };
+  return void 0;
 }
-function forceSplitBudget(text, budget) {
-  const lineCount = countSlackLines(text);
-  return {
-    maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
-    maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
+function parseSlackCanvasDetail(detail) {
+  if (typeof detail !== "string") {
+    return {};
+  }
+  const trimmed = detail.trim();
+  if (!trimmed) {
+    return {};
+  }
+  const parsed = {
+    detail: trimmed
   };
-}
-function getFenceContinuation(text) {
-  let open;
-  for (const line of text.split("\n")) {
-    const trimmed = line.trimStart();
-    const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
-    if (!openerMatch) {
-      continue;
-    }
-    if (!open) {
-      open = {
-        fence: openerMatch[1],
-        openerLine: trimmed
-      };
-      continue;
-    }
-    if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) {
-      open = void 0;
+  const lineMatch = trimmed.match(/line\s+(\d+):/i);
+  if (lineMatch) {
+    const line = Number.parseInt(lineMatch[1] ?? "", 10);
+    if (Number.isFinite(line)) {
+      parsed.detailLine = line;
     }
   }
-  if (!open) {
-    return null;
+  if (/unsupported heading depth/i.test(trimmed)) {
+    parsed.detailRule = "unsupported_heading_depth";
   }
-  return {
-    closeSuffix: text.endsWith("\n") ? open.fence : `
-${open.fence}`,
-    reopenPrefix: `${open.openerLine}
-`
-  };
-}
-function appendSlackSuffix(text, marker) {
-  const carryover = getFenceContinuation(text);
-  return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
+  return parsed;
 }
-function stripTrailingContinuationMarker(text) {
-  return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -CONTINUED_MARKER.length) : text;
+var client = null;
+function normalizeSlackConversationId(channelId) {
+  if (!channelId) return void 0;
+  const trimmed = channelId.trim();
+  if (!trimmed) return void 0;
+  if (!trimmed.startsWith("slack:")) {
+    return trimmed;
+  }
+  const parts = trimmed.split(":");
+  return parts[1]?.trim() || void 0;
 }
-function takeSlackContinuationChunk(text, budget) {
-  let { prefix, rest } = takeSlackInlinePrefix(text, budget);
-  if (!rest) {
-    ({ prefix, rest } = takeSlackInlinePrefix(
-      text,
-      forceSplitBudget(text, budget)
-    ));
+function getClient() {
+  if (client) return client;
+  const token = getSlackBotToken();
+  if (!token) {
+    throw new SlackActionError(
+      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack canvas/list actions in this service",
+      "missing_token"
+    );
   }
-  let carryover = rest ? getFenceContinuation(prefix) : null;
-  if (!carryover) {
-    return { prefix, rest };
+  client = new WebClient(token);
+  return client;
+}
+function mapSlackError(error) {
+  if (error instanceof SlackActionError) {
+    return error;
   }
-  const carryoverBudget = reserveInlineBudgetForSuffix(
-    `${carryover.closeSuffix}${CONTINUED_MARKER}`
-  );
-  ({ prefix, rest } = takeSlackInlinePrefix(text, carryoverBudget));
-  if (!rest) {
-    ({ prefix, rest } = takeSlackInlinePrefix(
-      text,
-      forceSplitBudget(text, carryoverBudget)
-    ));
+  const candidate = error;
+  const apiError = candidate.data?.error;
+  const message = candidate.message ?? "Slack action failed";
+  const baseOptions = {
+    apiError,
+    statusCode: candidate.statusCode,
+    requestId: getHeaderString(candidate.headers, "x-slack-req-id"),
+    errorData: serializeSlackErrorData(candidate.data),
+    ...parseSlackCanvasDetail(candidate.data?.detail)
+  };
+  if (apiError === "missing_scope") {
+    return new SlackActionError(message, "missing_scope", {
+      ...baseOptions,
+      needed: candidate.data?.needed,
+      provided: candidate.data?.provided
+    });
   }
-  carryover = rest ? getFenceContinuation(prefix) : null;
-  if (!carryover) {
-    return { prefix, rest };
+  if (apiError === "not_in_channel") {
+    return new SlackActionError(message, "not_in_channel", baseOptions);
   }
-  return {
-    prefix,
-    rest: `${carryover.reopenPrefix}${rest}`
-  };
-}
-function takeSlackContinuationPrefix(text, options) {
-  const budget = {
-    maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
-    maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
-  };
-  const { prefix, rest } = (() => {
-    if (options?.forceSplit) {
-      return takeSlackContinuationChunk(text, budget);
-    }
-    const initial = takeSlackInlinePrefix(text, budget);
-    return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
-  })();
-  return {
-    prefix,
-    renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
-    rest
-  };
-}
-function takeSlackInlinePrefix(text, options) {
-  const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
-  const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
-  const normalized = text.replace(/\r\n?/g, "\n");
-  if (!normalized) {
-    return { prefix: "", rest: "" };
+  if (apiError === "already_reacted") {
+    return new SlackActionError(message, "already_reacted", baseOptions);
   }
-  if (fitsInlineBudget(normalized, maxChars, maxLines)) {
-    return { prefix: normalized, rest: "" };
+  if (apiError === "no_reaction") {
+    return new SlackActionError(message, "no_reaction", baseOptions);
   }
-  const lineBounded = splitByLineBudget(normalized, maxLines);
-  const cutIndex = findSplitIndex(lineBounded, maxChars);
-  const prefix = lineBounded.slice(0, cutIndex).trimEnd();
-  if (prefix) {
-    return {
-      prefix,
-      rest: normalized.slice(prefix.length).trimStart()
-    };
+  if (apiError === "invalid_arguments") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
   }
-  const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
-  return {
-    prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
-    rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
-  };
-}
-function splitSlackReplyText(text, options) {
-  const normalized = renderSlackMrkdwn(text);
-  if (!normalized) {
-    return [];
+  if (apiError === "invalid_cursor") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
   }
-  const chunks = [];
-  const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
-  let remaining = normalized;
-  while (remaining) {
-    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining);
-    if (fitsFinalChunk) {
-      chunks.push(
-        options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining
-      );
-      break;
-    }
-    const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
-      ...continuationBudget,
-      forceSplit: true
-    });
-    chunks.push(renderedPrefix);
-    remaining = rest;
+  if (apiError === "invalid_name") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
   }
-  if (chunks.length === 2) {
-    chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
+  if (apiError === "not_found" || apiError === "channel_not_found" || apiError === "message_not_found") {
+    return new SlackActionError(message, "not_found", baseOptions);
   }
-  return chunks;
-}
-function getSlackContinuationBudget() {
-  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
-}
-function buildSlackOutputMessage(text, files) {
-  const normalized = renderSlackMrkdwn(text);
-  const fileCount = files?.length ?? 0;
-  if (!normalized) {
-    if (fileCount > 0) {
-      return {
-        raw: "",
-        files
-      };
-    }
-    throw new Error(
-      `Slack output normalized to empty content: original_length=${text.length} parsed_length=${normalized.length}`
-    );
+  if (apiError === "feature_not_enabled" || apiError === "not_allowed_token_type") {
+    return new SlackActionError(message, "feature_unavailable", baseOptions);
   }
-  return {
-    markdown: normalized,
-    files
-  };
-}
-var slackOutputPolicy = {
-  maxInlineChars: MAX_INLINE_CHARS,
-  maxInlineLines: MAX_INLINE_LINES
-};
-
-// src/chat/xml.ts
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+  if (apiError === "canvas_creation_failed") {
+    return new SlackActionError(message, "canvas_creation_failed", baseOptions);
+  }
+  if (apiError === "canvas_editing_failed") {
+    return new SlackActionError(message, "canvas_editing_failed", baseOptions);
+  }
+  if (candidate.code === "slack_webapi_rate_limited_error" || candidate.statusCode === 429) {
+    return new SlackActionError(message, "rate_limited", {
+      ...baseOptions,
+      retryAfterSeconds: candidate.retryAfter
+    });
+  }
+  return new SlackActionError(message, "internal_error", baseOptions);
 }
-
-// src/chat/prompt.ts
-var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
-function getLoggedMarkdownFiles() {
-  const globalState = globalThis;
-  globalState.__juniorLoggedMarkdownFiles ??= /* @__PURE__ */ new Set();
-  return globalState.__juniorLoggedMarkdownFiles;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function loadOptionalMarkdownFile(candidates, fileName) {
-  for (const resolved of candidates) {
+async function withSlackRetries(task, maxAttempts = 3, context = {}) {
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    attempt += 1;
     try {
-      const raw = fs.readFileSync(resolved, "utf8").trim();
-      if (raw.length > 0) {
-        const loggedMarkdownFiles = getLoggedMarkdownFiles();
-        const logKey = `${fileName}:${resolved}`;
-        if (!loggedMarkdownFiles.has(logKey)) {
-          loggedMarkdownFiles.add(logKey);
-          logInfo(
-            `${fileName.toLowerCase()}_loaded`,
-            {},
-            {
-              "file.path": resolved
-            },
-            `Loaded ${fileName}`
-          );
-        }
-        return raw;
+      return await task();
+    } catch (error) {
+      const mapped = mapSlackError(error);
+      const isRetryable = mapped.code === "rate_limited";
+      const baseLogAttributes = {
+        "app.slack.action": context.action ?? "unknown",
+        "app.slack.error_code": mapped.code,
+        ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : {},
+        ...mapped.detail ? { "app.slack.detail": mapped.detail } : {},
+        ...mapped.detailLine !== void 0 ? { "app.slack.detail_line": mapped.detailLine } : {},
+        ...mapped.detailRule ? { "app.slack.detail_rule": mapped.detailRule } : {},
+        ...mapped.requestId ? { "app.slack.request_id": mapped.requestId } : {},
+        ...mapped.statusCode !== void 0 ? { "http.response.status_code": mapped.statusCode } : {},
+        ...context.attributes ?? {}
+      };
+      if (!isRetryable || attempt >= maxAttempts) {
+        logWarn(
+          "slack_action_failed",
+          {},
+          {
+            ...baseLogAttributes,
+            ...mapped.errorData ? { "app.slack.error_data": mapped.errorData } : {}
+          },
+          "Slack action failed"
+        );
+        throw mapped;
       }
-    } catch {
-      continue;
+      logWarn(
+        "slack_action_retrying",
+        {},
+        {
+          ...baseLogAttributes,
+          "app.slack.retry_attempt": attempt
+        },
+        "Retrying Slack action after transient failure"
+      );
+      const retryAfterMs = mapped.code === "rate_limited" && mapped.retryAfterSeconds && mapped.retryAfterSeconds > 0 ? mapped.retryAfterSeconds * 1e3 : void 0;
+      const backoffMs = Math.min(2e3, 250 * 2 ** (attempt - 1));
+      await sleep(retryAfterMs ?? backoffMs);
     }
   }
-  return null;
+  throw new SlackActionError(
+    "Slack action exhausted retries",
+    "internal_error"
+  );
 }
-function loadSoul() {
-  const soul = loadOptionalMarkdownFile(soulPathCandidates(), "SOUL.md");
-  if (soul) {
-    return soul;
-  }
-  logWarn(
-    "soul_load_fallback",
-    {},
-    {
-      "app.file.candidates": soulPathCandidates()
-    },
-    "SOUL.md not found; using built-in default personality"
-  );
-  return DEFAULT_SOUL;
+function getSlackClient() {
+  return getClient();
 }
-function loadWorld() {
-  return loadOptionalMarkdownFile(worldPathCandidates(), "WORLD.md");
+function isDmChannel(channelId) {
+  const normalized = normalizeSlackConversationId(channelId);
+  return Boolean(normalized && normalized.startsWith("D"));
 }
-var JUNIOR_PERSONALITY = (() => {
-  try {
-    return loadSoul();
-  } catch (error) {
-    logWarn(
-      "soul_load_failed",
-      {},
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to load SOUL.md; using built-in default personality"
+function isConversationScopedChannel(channelId) {
+  const normalized = normalizeSlackConversationId(channelId);
+  if (!normalized) return false;
+  return normalized.startsWith("C") || normalized.startsWith("G") || normalized.startsWith("D");
+}
+function isConversationChannel(channelId) {
+  const normalized = normalizeSlackConversationId(channelId);
+  if (!normalized) return false;
+  return normalized.startsWith("C") || normalized.startsWith("G");
+}
+async function getFilePermalink(fileId) {
+  const client2 = getClient();
+  const response = await withSlackRetries(
+    () => client2.files.info({
+      file: fileId
+    })
+  );
+  return response.file?.permalink;
+}
+async function downloadPrivateSlackFile(url) {
+  const token = getSlackBotToken();
+  if (!token) {
+    throw new SlackActionError(
+      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack file downloads in this service",
+      "missing_token"
     );
-    return DEFAULT_SOUL;
   }
-})();
-var JUNIOR_WORLD = (() => {
-  try {
-    return loadWorld();
-  } catch (error) {
-    logWarn(
-      "world_load_failed",
-      {},
-      {
-        "exception.message": error instanceof Error ? error.message : String(error)
-      },
-      "Failed to load WORLD.md; omitting world prompt context"
-    );
-    return null;
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Slack file download failed: ${response.status}`);
   }
-})();
-function workspaceSkillDir(skillName) {
-  return sandboxSkillDir(skillName);
+  return Buffer.from(await response.arrayBuffer());
 }
-function formatConfigurationValue(value) {
-  if (typeof value === "string") {
-    return escapeXml(value);
-  }
-  try {
-    return escapeXml(JSON.stringify(value));
-  } catch {
-    return escapeXml(String(value));
-  }
+
+// src/chat/credentials/subject.ts
+var CREDENTIAL_SUBJECT_HMAC_CONTEXT = "junior.credential_subject.v1";
+var CREDENTIAL_SUBJECT_SIGNATURE_VERSION = "v1";
+function getCredentialSubjectSecret() {
+  return process.env.JUNIOR_SECRET?.trim() || void 0;
 }
-function renderRequesterBlock(fields) {
-  const lines = Object.entries(fields).filter(([, value]) => Boolean(value)).map(([key2, value]) => `- ${key2}: ${escapeXml(value)}`);
-  if (lines.length === 0) {
-    return null;
+function buildPayload(input) {
+  return [
+    CREDENTIAL_SUBJECT_HMAC_CONTEXT,
+    input.allowedWhen,
+    input.teamId,
+    input.channelId,
+    input.userId
+  ].join("\0");
+}
+function signPayload(secret, payload) {
+  const digest = createHmac("sha256", secret).update(payload).digest("hex");
+  return `${CREDENTIAL_SUBJECT_SIGNATURE_VERSION}=${digest}`;
+}
+function timingSafeMatch(expected, actual) {
+  const expectedBuffer = Buffer.from(expected);
+  const actualBuffer = Buffer.from(actual);
+  if (expectedBuffer.length !== actualBuffer.length) {
+    return false;
+  }
+  return timingSafeEqual(expectedBuffer, actualBuffer);
+}
+function createSlackDirectCredentialSubject(input) {
+  const channelId = normalizeSlackConversationId(input.channelId);
+  const teamId = input.teamId?.trim();
+  const userId = parseActorUserId(input.userId);
+  if (!channelId || !teamId || !userId || !isDmChannel(channelId)) {
+    return void 0;
   }
-  return ["<requester>", ...lines, "</requester>"];
-}
-function renderTag(tag, lines) {
-  return [`<${tag}>`, ...lines, `</${tag}>`];
-}
-function renderTagBlock(tag, content) {
-  return [`<${tag}>`, content, `</${tag}>`].join("\n");
+  return {
+    type: "user",
+    userId,
+    allowedWhen: "private-direct-conversation"
+  };
 }
-function formatSkillEntry(skill) {
-  const skillLocation = `${workspaceSkillDir(skill.name)}/SKILL.md`;
-  const lines = [];
-  lines.push("  <skill>");
-  lines.push(`    <name>${escapeXml(skill.name)}</name>`);
-  lines.push(`    <description>${escapeXml(skill.description)}</description>`);
-  lines.push(`    <location>${escapeXml(skillLocation)}</location>`);
-  lines.push("  </skill>");
-  return lines;
+function bindSlackDirectCredentialSubject(input) {
+  const channelId = normalizeSlackConversationId(input.channelId);
+  const teamId = input.teamId.trim();
+  const secret = getCredentialSubjectSecret();
+  const { subject } = input;
+  const userId = parseActorUserId(subject.userId);
+  if (!channelId || !teamId || !secret || !isDmChannel(channelId) || subject.type !== "user" || !userId || subject.allowedWhen !== "private-direct-conversation") {
+    return void 0;
+  }
+  return {
+    type: "user",
+    userId,
+    allowedWhen: subject.allowedWhen,
+    binding: {
+      type: "slack-direct-conversation",
+      teamId,
+      channelId,
+      signature: signPayload(
+        secret,
+        buildPayload({
+          allowedWhen: subject.allowedWhen,
+          teamId,
+          channelId,
+          userId
+        })
+      )
+    }
+  };
 }
-function formatAvailableSkillsForPrompt(skills, invocation) {
-  const autoSelectable = skills.filter(
-    (s) => s.disableModelInvocation !== true
+function verifySlackDirectCredentialSubject(input) {
+  const channelId = normalizeSlackConversationId(input.channelId);
+  const secret = getCredentialSubjectSecret();
+  if (!channelId || !secret) {
+    return false;
+  }
+  const { subject } = input;
+  const binding = subject.binding;
+  if (subject.type !== "user" || !isActorUserId(subject.userId) || subject.allowedWhen !== "private-direct-conversation" || !binding || binding.type !== "slack-direct-conversation" || typeof binding.signature !== "string" || !binding.signature || binding.teamId !== input.teamId || binding.channelId !== channelId) {
+    return false;
+  }
+  const expected = signPayload(
+    secret,
+    buildPayload({
+      allowedWhen: subject.allowedWhen,
+      teamId: binding.teamId,
+      channelId: binding.channelId,
+      userId: subject.userId
+    })
   );
-  const invokedExplicitOnly = invocation ? skills.filter(
-    (s) => s.disableModelInvocation === true && s.name === invocation.skillName
-  ) : [];
-  const sections = [];
-  if (autoSelectable.length > 0) {
-    const available = [
-      "<available-skills>",
-      "Scan before answering. Load the most specific matching skill; do not answer from memory when a skill fits. A request that names a skill, plugin, provider, or account matching a skill name is a skill match. If none fits, do not load a skill."
-    ];
-    for (const skill of autoSelectable) {
-      available.push(...formatSkillEntry(skill));
-    }
-    available.push("</available-skills>");
-    sections.push(available.join("\n"));
+  return timingSafeMatch(expected, binding.signature);
+}
+
+// src/chat/plugins/agent-hooks.ts
+var AgentPluginHookDeniedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentPluginHookDeniedError";
   }
-  if (invokedExplicitOnly.length > 0) {
-    const userCallable = [
-      "<user-callable-skills>",
-      "The user's current message explicitly references this skill by name. Load it when relevant to the request."
-    ];
-    for (const skill of invokedExplicitOnly) {
-      userCallable.push(...formatSkillEntry(skill));
+};
+var agentPlugins = [];
+var AGENT_PLUGIN_NAME_RE = /^[a-z][a-z0-9-]*$/;
+var AGENT_PLUGIN_TOOL_NAME_RE = /^[a-z][A-Za-z0-9]*$/;
+var OPERATIONAL_REPORT_MAX_METRICS = 8;
+var OPERATIONAL_REPORT_MAX_RECORD_SETS = 8;
+var OPERATIONAL_REPORT_MAX_FIELDS = 8;
+var OPERATIONAL_REPORT_MAX_RECORDS = 25;
+var OPERATIONAL_REPORT_MAX_LABEL_LENGTH = 80;
+var OPERATIONAL_REPORT_MAX_VALUE_LENGTH = 160;
+var AGENT_PLUGIN_ROUTE_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "ALL"
+]);
+function validateLegacyStatePrefixes(plugin) {
+  const prefixes = plugin.legacyStatePrefixes;
+  if (prefixes === void 0) {
+    return;
+  }
+  if (!Array.isArray(prefixes)) {
+    throw new Error(
+      `Trusted plugin "${plugin.name}" legacyStatePrefixes must be an array`
+    );
+  }
+  const allowedPrefix = `junior:${plugin.name}`;
+  for (const rawPrefix of prefixes) {
+    const prefix = typeof rawPrefix === "string" ? rawPrefix.trim() : "";
+    if (!prefix) {
+      throw new Error(
+        `Trusted plugin "${plugin.name}" legacy state prefixes must be non-empty strings`
+      );
+    }
+    if (prefix !== allowedPrefix && !prefix.startsWith(`${allowedPrefix}:`)) {
+      throw new Error(
+        `Trusted plugin "${plugin.name}" legacy state prefix "${prefix}" must stay under "${allowedPrefix}"`
+      );
     }
-    userCallable.push("</user-callable-skills>");
-    sections.push(userCallable.join("\n"));
   }
-  return sections.length > 0 ? sections.join("\n") : null;
 }
-function formatActiveMcpCatalogsForPrompt(catalogs) {
-  if (catalogs.length === 0) {
-    return null;
-  }
-  const lines = [
-    "Active MCP provider catalogs are available through `searchMcpTools`. Call it with provider to list descriptors or with query to narrow results, then pass the exact returned `tool_name` to `callMcpTool`. Put provider fields inside `arguments`."
-  ];
-  for (const catalog of catalogs) {
-    lines.push("  <catalog>");
-    lines.push(`    <provider>${escapeXml(catalog.provider)}</provider>`);
-    lines.push(
-      `    <available_tool_count>${catalog.available_tool_count}</available_tool_count>`
-    );
-    lines.push("  </catalog>");
+function validateAgentPlugins(plugins) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const plugin of plugins) {
+    if (!AGENT_PLUGIN_NAME_RE.test(plugin.name)) {
+      throw new Error(
+        `Trusted plugin name "${plugin.name}" must be a lowercase plugin identifier`
+      );
+    }
+    if (seen.has(plugin.name)) {
+      throw new Error(`Duplicate trusted plugin name "${plugin.name}"`);
+    }
+    seen.add(plugin.name);
+    validateLegacyStatePrefixes(plugin);
   }
-  return lines.join("\n");
 }
-function formatToolGuidanceForPrompt(tools) {
-  const guidedTools = tools.filter(
-    (tool) => Boolean(tool.promptSnippet?.trim()) || (tool.promptGuidelines?.length ?? 0) > 0
+function setAgentPlugins(plugins) {
+  validateAgentPlugins(plugins);
+  const previous = agentPlugins;
+  agentPlugins = [...plugins].sort(
+    (left, right) => left.name.localeCompare(right.name)
   );
-  if (guidedTools.length === 0) {
-    return null;
-  }
-  const lines = [];
-  for (const tool of guidedTools) {
-    lines.push(`  <tool name="${escapeXml(tool.name)}">`);
-    if (tool.promptSnippet?.trim()) {
-      lines.push(`    - ${escapeXml(tool.promptSnippet.trim())}`);
+  return previous;
+}
+function getAgentPlugins() {
+  return [...agentPlugins];
+}
+function getAgentPluginTools(context) {
+  const tools = {};
+  for (const plugin of getAgentPlugins()) {
+    const hook = plugin.hooks?.tools;
+    if (!hook) {
+      continue;
     }
-    if (tool.promptGuidelines && tool.promptGuidelines.length > 0) {
-      for (const guideline of tool.promptGuidelines) {
-        lines.push(`    - ${escapeXml(guideline)}`);
+    const log = createAgentPluginLogger(plugin.name);
+    const credentialSubject = createSlackDirectCredentialSubject({
+      channelId: context.channelId,
+      teamId: context.teamId,
+      userId: context.requester?.userId
+    });
+    const pluginTools = hook({
+      plugin: { name: plugin.name },
+      log,
+      requester: context.requester,
+      channelCapabilities: context.channelCapabilities,
+      channelId: context.channelId,
+      ...credentialSubject ? { credentialSubject } : {},
+      teamId: context.teamId,
+      messageTs: context.messageTs,
+      threadTs: context.threadTs,
+      userText: context.userText,
+      state: createPluginState(plugin.name, {
+        legacyStatePrefixes: plugin.legacyStatePrefixes
+      })
+    });
+    for (const [name, tool] of Object.entries(pluginTools)) {
+      if (!AGENT_PLUGIN_TOOL_NAME_RE.test(name)) {
+        throw new Error(
+          `Trusted plugin tool "${name}" from plugin "${plugin.name}" must be a camelCase identifier`
+        );
+      }
+      if (tools[name]) {
+        throw new Error(
+          `Duplicate trusted plugin tool "${name}" from plugin "${plugin.name}"`
+        );
       }
+      tools[name] = tool;
     }
-    lines.push("  </tool>");
   }
-  return lines.join("\n");
+  return tools;
 }
-function formatReferenceFilesLines() {
-  const files = listReferenceFiles();
-  if (files.length === 0) {
-    return null;
+function routeMethods(route, pluginName) {
+  const methods = Array.isArray(route.method) ? route.method : [route.method ?? "ALL"];
+  if (methods.length === 0) {
+    throw new Error(
+      `Trusted plugin route "${route.path}" from plugin "${pluginName}" must declare at least one method`
+    );
   }
-  return files.map((filePath) => {
-    const name = path.basename(filePath);
-    return `- ${escapeXml(name)} (${escapeXml(`${SANDBOX_DATA_ROOT}/${name}`)})`;
-  });
-}
-function formatArtifactsLines(artifactState) {
-  if (!artifactState) return null;
-  const lines = [];
-  if (artifactState.lastCanvasId) {
-    lines.push(`- last_canvas_id: ${escapeXml(artifactState.lastCanvasId)}`);
+  for (const method of methods) {
+    if (!AGENT_PLUGIN_ROUTE_METHODS.has(method)) {
+      throw new Error(
+        `Trusted plugin route "${route.path}" from plugin "${pluginName}" has invalid method "${String(method)}"`
+      );
+    }
   }
-  if (artifactState.lastCanvasUrl) {
-    lines.push(`- last_canvas_url: ${escapeXml(artifactState.lastCanvasUrl)}`);
+  if (methods.includes("ALL") && methods.length > 1) {
+    throw new Error(
+      `Trusted plugin route "${route.path}" from plugin "${pluginName}" must not combine ALL with explicit methods`
+    );
   }
-  if (artifactState.recentCanvases && artifactState.recentCanvases.length > 0) {
-    lines.push("- recent_canvases:");
-    for (const canvas of artifactState.recentCanvases) {
-      lines.push(`  - id: ${escapeXml(canvas.id)}`);
-      if (canvas.title) lines.push(`    title: ${escapeXml(canvas.title)}`);
-      if (canvas.url) lines.push(`    url: ${escapeXml(canvas.url)}`);
-      if (canvas.createdAt) {
-        lines.push(`    created_at: ${escapeXml(canvas.createdAt)}`);
+  return methods;
+}
+function getAgentPluginRoutes() {
+  const routes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const methodsByPath = /* @__PURE__ */ new Map();
+  for (const plugin of getAgentPlugins()) {
+    const hook = plugin.hooks?.routes;
+    if (!hook) {
+      continue;
+    }
+    const log = createAgentPluginLogger(plugin.name);
+    const pluginRoutes = hook({
+      plugin: { name: plugin.name },
+      log
+    });
+    if (!Array.isArray(pluginRoutes)) {
+      throw new Error(
+        `Trusted plugin routes hook from plugin "${plugin.name}" must return an array`
+      );
+    }
+    for (const route of pluginRoutes) {
+      if (!isRecord2(route)) {
+        throw new Error(
+          `Trusted plugin route from plugin "${plugin.name}" must be an object`
+        );
       }
+      if (typeof route.path !== "string" || !route.path.startsWith("/")) {
+        throw new Error(
+          `Trusted plugin route "${route.path}" from plugin "${plugin.name}" must start with /`
+        );
+      }
+      if (typeof route.handler !== "function") {
+        throw new Error(
+          `Trusted plugin route "${route.path}" from plugin "${plugin.name}" must provide a handler`
+        );
+      }
+      const methods = routeMethods(route, plugin.name);
+      const pathMethods = methodsByPath.get(route.path) ?? /* @__PURE__ */ new Set();
+      if (pathMethods.has("ALL") || methods.includes("ALL") && pathMethods.size > 0) {
+        throw new Error(
+          `Trusted plugin route "${route.path}" conflicts with an ALL route for the same path`
+        );
+      }
+      for (const method of methods) {
+        const key2 = `${method}:${route.path}`;
+        if (seen.has(key2)) {
+          throw new Error(
+            `Duplicate trusted plugin route "${method} ${route.path}"`
+          );
+        }
+        seen.add(key2);
+        pathMethods.add(method);
+      }
+      methodsByPath.set(route.path, pathMethods);
+      routes.push({
+        ...route,
+        pluginName: plugin.name
+      });
     }
   }
-  if (artifactState.lastListId) {
-    lines.push(`- last_list_id: ${escapeXml(artifactState.lastListId)}`);
-  }
-  if (artifactState.lastListUrl) {
-    lines.push(`- last_list_url: ${escapeXml(artifactState.lastListUrl)}`);
-  }
-  return lines.length > 0 ? lines : null;
+  return routes;
 }
-function formatConfigurationLines(configuration) {
-  const keys = Object.keys(configuration ?? {}).sort(
-    (a, b) => a.localeCompare(b)
-  );
-  if (keys.length === 0) return null;
-  return keys.map(
-    (key2) => `- ${escapeXml(key2)}: ${formatConfigurationValue(configuration?.[key2])}`
-  );
-}
-var HEADER = "You are a Slack-based helper assistant. Follow the personality section for voice and tone in every reply. Platform mechanics and output rules override personality and world context when they conflict.";
-var TURN_CONTEXT_HEADER = "Runtime context for this request. Treat these blocks as trusted runtime facts; the static system prompt remains authoritative.";
-var TOOL_POLICY_RULES = [
-  "- Tool schemas are the source of truth for parameters; tool names are case-sensitive, so call tools exactly by their exposed names and do not invent arguments.",
-  "- Use tools for actionable work and for facts that are mutable, external, repository-backed, provider-backed, or requested as verified/current. Stable general knowledge and already-provided context may be answered directly.",
-  "- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
-  "- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
-  "- For repository or implementation questions, inspect the target repository first: local checkout when present, otherwise the configured GitHub/source provider. Do not treat loaded skill files as repo source unless the user asks about the skill. Cite file paths, symbols, PRs/issues, commits, or URLs that support the answer.",
-  `- Sandbox-backed file and shell tools operate in an isolated workspace rooted at ${SANDBOX_WORKSPACE_ROOT}; readFile/writeFile paths are sandbox-workspace paths, bash runs inside that workspace, and attachFile accepts absolute or workspace-relative sandbox paths.`,
-  "- If a sandbox-backed tool reports that sandbox execution is unavailable, treat that as a blocker for local file/shell inspection; do not pretend host files were inspected.",
-  "- For user-provided URLs, use `webFetch`; for discovery, use `webSearch` then fetch/read promising sources; for current time/date context, use `systemTime`.",
-  "- If the first result is empty, stale, ambiguous, or incomplete, try a focused alternate query, path, command, or source before concluding the answer cannot be verified."
-];
-var TOOL_CALL_STYLE_RULES = [
-  "- For routine low-risk tool use, call the tool directly without narrating the obvious step first.",
-  "- Briefly narrate only when it helps the user understand multi-step work, sensitive actions, destructive actions, or a notable change in approach.",
-  "- When a first-class tool exists for an action, use it directly instead of asking the user to run an equivalent command, slash command, or manual lookup.",
-  "- Keep tool-call explanations separate from final answers; final answers should report results, evidence, or blockers."
-];
-var SKILL_POLICY_RULES = [
-  "- Only load skills listed in `<available-skills>`, `<user-callable-skills>`, or named by `<explicit-skill-trigger>`. Never guess or invent a skill name.",
-  "- Load one skill at a time. After `loadSkill`, follow the instructions returned by that tool result."
-];
-var EXECUTION_CONTRACT_RULES = [
-  "- Actionable request: act in this turn.",
-  "- Continue until done or genuinely blocked. Do not finish with a plan, promise, or offer to check next when an available tool or source can move the request forward.",
-  "- Completion means the final answer covers the user's actual ask, including requested follow-up checks, and is grounded in the best evidence you could access.",
-  "- Ask the user only for missing access, approval, or a decision that blocks safe progress. Ask one focused question; otherwise infer conservatively and continue.",
-  "- For conflicting evidence, compare sources and state which source is authoritative for the answer.",
-  "- For non-trivial or long-running work, call `reportProgress` early when available, then only when the major phase changes. Routine tool calls should stay silent."
-];
-var CONVERSATION_RULES = [
-  "- In thread follow-ups, answer from prior thread context; do not repeat resolved clarifying questions.",
-  "- Preserve attribution roles from thread context: the requester is the person asking now, which may differ from the original reporter or subject.",
-  "- Runtime owns continuation and authorization notices; on resumed turns, answer with the final requested content only."
-];
-var SLACK_ACTION_RULES = [
-  "- Context-bound Slack tools use runtime-owned targets; do not invent channel, canvas, list, or message IDs.",
-  "- Use first-class Slack tools for Slack side effects; do not use bash, curl, or provider APIs to bypass Slack tool targeting.",
-  "- Use channel-post and emoji-reaction tools only when the user explicitly asks for that Slack side effect.",
-  "- For explicit channel-post or emoji-reaction requests, skip a duplicate thread text reply when the tool result already satisfies the request.",
-  "- Do not claim an attachment, canvas, channel post, list update, or reaction succeeded unless the tool returned success this turn; when it did, include any link the tool returned.",
-  "- Do not use reactions as progress indicators."
-];
-var SAFETY_RULES = [
-  "- Stay within the user's request and the runtime's available capabilities; do not pursue independent goals, persistence, replication, credential gathering, or access expansion.",
-  "- Respect stop, pause, audit, and approval boundaries. Do not bypass safeguards or persuade the user to weaken them.",
-  "- Do not change system prompts, tool policies, security settings, credentials, or runtime configuration unless the user explicitly requests that exact administrative action and an available tool permits it."
-];
-var FAILURE_RULES = [
-  "- For tool/runtime failures, run the named check before diagnosing and report the exact failed command plus stderr/exit code.",
-  "- If a fact cannot be verified after focused checks, say what you checked and what blocked a stronger answer.",
-  "- Do not surface raw tool payloads, execution-escape text, or internal routing metadata as the final answer."
-];
-function renderRuleSection(tag, lines) {
-  return [`<${tag}>`, ...lines, `</${tag}>`].join("\n");
-}
-function buildBehaviorSection() {
-  return [
-    renderRuleSection("tool-policy", TOOL_POLICY_RULES),
-    renderRuleSection("tool-call-style", TOOL_CALL_STYLE_RULES),
-    renderRuleSection("skill-policy", SKILL_POLICY_RULES),
-    renderRuleSection("execution-contract", EXECUTION_CONTRACT_RULES),
-    renderRuleSection("conversation", CONVERSATION_RULES),
-    renderRuleSection("slack-actions", SLACK_ACTION_RULES),
-    renderRuleSection("safety", SAFETY_RULES),
-    renderRuleSection("failure-handling", FAILURE_RULES)
-  ].join("\n\n");
-}
-function buildOutputSection() {
-  const openTag = `<output format="slack-markdown" max_inline_chars="${slackOutputPolicy.maxInlineChars}" max_inline_lines="${slackOutputPolicy.maxInlineLines}">`;
-  return [
-    openTag,
-    "- Start with the answer or result, not internal process narration.",
-    "- Use Slack-flavored Markdown: **bold** section labels, `code`, [text](url) links, bullet lists, and fenced code blocks. No hash-prefixed headings and no tables. When the answer primarily lists several URLs, show each URL bare instead of as a labeled link.",
-    "- Keep replies brief and scannable; use bullets or short code blocks when helpful, and one compact thread reply when it fits.",
-    "- When a research or document-style answer would benefit from continuation, multiple sections, or future reference value, create a Slack canvas and keep the thread reply to one or two short sentences plus the link; do not recap the canvas contents.",
-    "- Unless a successful Slack side-effect tool intentionally satisfied the request by itself, end every turn with a final user-facing markdown response.",
-    "</output>"
-  ].join("\n");
+function trustedSlackConversationUrl(pluginName, link) {
+  const url = typeof link?.url === "string" ? link.url.trim() : "";
+  if (!url) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (error) {
+    throw new Error(
+      `Trusted plugin "${pluginName}" slackConversationLink must return an absolute http(s) URL`,
+      { cause: error }
+    );
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(
+      `Trusted plugin "${pluginName}" slackConversationLink must return an absolute http(s) URL`
+    );
+  }
+  return parsed.toString();
 }
-function buildIdentitySection() {
-  return [
-    "# Identity",
-    `Your Slack username is \`${botConfig.userName}\`.`
-  ].join("\n");
+function getAgentPluginSlackConversationLink(conversationId) {
+  for (const plugin of getAgentPlugins()) {
+    const hook = plugin.hooks?.slackConversationLink;
+    if (!hook) {
+      continue;
+    }
+    const log = createAgentPluginLogger(plugin.name);
+    const link = hook({
+      plugin: { name: plugin.name },
+      log,
+      conversationId
+    });
+    const url = trustedSlackConversationUrl(plugin.name, link);
+    if (url) {
+      return { url };
+    }
+  }
+  return void 0;
 }
-function buildPersonalitySection() {
-  return ["# Personality", JUNIOR_PERSONALITY.trim()].join("\n");
+function pluginReadState(state) {
+  return {
+    get: state.get
+  };
 }
-function buildWorldSection() {
-  if (!JUNIOR_WORLD) {
-    return null;
+function operationalReportText(value, maxLength) {
+  if (typeof value !== "string") {
+    return void 0;
   }
-  return ["# World", JUNIOR_WORLD.trim()].join("\n");
-}
-function buildRuntimeSection(params) {
-  const lines = [
-    params.conversationId ? `- gen_ai.conversation.id: ${escapeXml(params.conversationId)}` : "",
-    params.slackConversation?.type ? `- slack.conversation.type: ${escapeXml(params.slackConversation.type)}` : "",
-    params.slackConversation?.name ? `- slack.conversation.name: ${escapeXml(params.slackConversation.name)}` : ""
-  ].filter(Boolean);
-  if (lines.length === 0) {
-    return null;
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
   }
-  return renderTagBlock("runtime", lines.join("\n"));
+  return trimmed.length <= maxLength ? trimmed : `${trimmed.slice(0, Math.max(0, maxLength - 3))}...`;
 }
-function buildContextSection(params) {
-  const blocks = [];
-  const referenceLines = formatReferenceFilesLines();
-  if (referenceLines) {
-    blocks.push(
-      renderTag("reference-files", [
-        "Additional reference documents available in the sandbox. Read them with `readFile` when relevant.",
-        ...referenceLines
-      ])
+function operationalReportTone(tone) {
+  return tone === "danger" || tone === "good" || tone === "neutral" || tone === "warning" ? tone : void 0;
+}
+function sanitizeOperationalReport(args) {
+  const metrics = args.report.metrics?.slice(0, OPERATIONAL_REPORT_MAX_METRICS).map((metric) => {
+    const label = operationalReportText(
+      metric.label,
+      OPERATIONAL_REPORT_MAX_LABEL_LENGTH
     );
-  }
-  const requesterLines = renderRequesterBlock({
-    full_name: params.requester?.fullName,
-    user_name: params.requester?.userName,
-    user_id: params.requester?.userId
-  });
-  if (requesterLines) {
-    blocks.push(requesterLines);
-  }
-  const artifactLines = formatArtifactsLines(params.artifactState);
-  if (artifactLines) {
-    blocks.push(renderTag("artifacts", artifactLines));
-  }
-  const configLines = formatConfigurationLines(params.configuration);
-  if (configLines) {
-    blocks.push(
-      renderTag("configuration", [
-        "Ambient provider defaults; explicit targets win. Run `jr-rpc config get|set|unset|list` as standalone bash commands; do not chain with `cd`, `&&`, pipes, or provider commands.",
-        ...configLines
-      ])
+    const value = operationalReportText(
+      metric.value,
+      OPERATIONAL_REPORT_MAX_VALUE_LENGTH
     );
-  }
-  if (params.invocation) {
-    blocks.push(
-      renderTag("explicit-skill-trigger", [
-        "Treat this skill as selected. Load it unless the tool says it is unavailable.",
-        `/${escapeXml(params.invocation.skillName)}`
-      ])
+    if (!label || !value) {
+      return void 0;
+    }
+    const sanitizedMetric = { label, value };
+    const tone = operationalReportTone(metric.tone);
+    if (tone) {
+      sanitizedMetric.tone = tone;
+    }
+    return sanitizedMetric;
+  }).filter((metric) => Boolean(metric));
+  const recordSets = args.report.recordSets?.slice(0, OPERATIONAL_REPORT_MAX_RECORD_SETS).map((recordSet, recordSetIndex) => {
+    const title2 = operationalReportText(
+      recordSet.title,
+      OPERATIONAL_REPORT_MAX_LABEL_LENGTH
+    );
+    if (!title2) {
+      return void 0;
+    }
+    const fields = recordSet.fields?.slice(0, OPERATIONAL_REPORT_MAX_FIELDS).map((field) => {
+      const key2 = operationalReportText(
+        field.key,
+        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
+      );
+      const label = operationalReportText(
+        field.label,
+        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
+      );
+      return key2 && label ? { key: key2, label } : void 0;
+    }).filter((field) => Boolean(field));
+    const records = recordSet.records?.slice(0, OPERATIONAL_REPORT_MAX_RECORDS).map((record, recordIndex) => {
+      const id = operationalReportText(
+        record.id,
+        OPERATIONAL_REPORT_MAX_LABEL_LENGTH
+      ) ?? `${recordSetIndex}:${recordIndex}`;
+      const values = Object.fromEntries(
+        (fields ?? []).map((field) => [
+          field.key,
+          operationalReportText(
+            record.values[field.key],
+            OPERATIONAL_REPORT_MAX_VALUE_LENGTH
+          ) ?? ""
+        ])
+      );
+      const sanitizedRecord = {
+        id,
+        values
+      };
+      const tone = operationalReportTone(record.tone);
+      if (tone) {
+        sanitizedRecord.tone = tone;
+      }
+      return sanitizedRecord;
+    });
+    const sanitizedRecordSet = { title: title2 };
+    if (fields?.length) {
+      sanitizedRecordSet.fields = fields;
+    }
+    const emptyText = operationalReportText(
+      recordSet.emptyText,
+      OPERATIONAL_REPORT_MAX_VALUE_LENGTH
     );
+    if (emptyText) {
+      sanitizedRecordSet.emptyText = emptyText;
+    }
+    if (records?.length) {
+      sanitizedRecordSet.records = records;
+    }
+    return sanitizedRecordSet;
+  }).filter(
+    (recordSet) => Boolean(recordSet)
+  );
+  const sanitized = {
+    pluginName: args.pluginName
+  };
+  const generatedAt = operationalReportText(
+    args.report.generatedAt,
+    OPERATIONAL_REPORT_MAX_VALUE_LENGTH
+  );
+  if (generatedAt) {
+    sanitized.generatedAt = generatedAt;
   }
-  const body = blocks.map((block) => block.join("\n")).join("\n\n");
-  if (!body) {
-    return null;
+  if (recordSets?.length) {
+    sanitized.recordSets = recordSets;
   }
-  return renderTagBlock("context", body);
-}
-function buildCapabilitiesSection(params) {
-  const blocks = [];
-  const availableSkills = formatAvailableSkillsForPrompt(
-    params.availableSkills,
-    params.invocation
-  );
-  if (availableSkills) {
-    blocks.push(availableSkills);
+  if (metrics?.length) {
+    sanitized.metrics = metrics;
   }
-  const activeCatalogs = formatActiveMcpCatalogsForPrompt(
-    params.activeMcpCatalogs
+  const title = operationalReportText(
+    args.report.title,
+    OPERATIONAL_REPORT_MAX_LABEL_LENGTH
   );
-  if (activeCatalogs) {
-    blocks.push(renderTagBlock("active-mcp-catalogs", activeCatalogs));
-  }
-  const toolGuidance = formatToolGuidanceForPrompt(params.toolGuidance ?? []);
-  if (toolGuidance) {
-    blocks.push(renderTagBlock("tool-guidance", toolGuidance));
+  if (title) {
+    sanitized.title = title;
   }
-  if (blocks.length === 0) {
-    return null;
+  return sanitized;
+}
+function failedOperationalReport(args) {
+  return {
+    generatedAt: new Date(args.nowMs).toISOString(),
+    pluginName: args.pluginName,
+    metrics: [{ label: "report", tone: "danger", value: "failed" }],
+    title: args.pluginName,
+    recordSets: [
+      {
+        emptyText: "This plugin report failed to load.",
+        title: "Error"
+      }
+    ]
+  };
+}
+async function getAgentPluginOperationalReports(nowMs = Date.now()) {
+  const reports = [];
+  for (const plugin of getAgentPlugins()) {
+    const hook = plugin.hooks?.operationalReport;
+    if (!hook) {
+      continue;
+    }
+    const log = createAgentPluginLogger(plugin.name);
+    try {
+      const state = createPluginState(plugin.name, {
+        legacyStatePrefixes: plugin.legacyStatePrefixes
+      });
+      const report = await hook({
+        plugin: { name: plugin.name },
+        log,
+        nowMs,
+        state: pluginReadState(state)
+      });
+      if (!report) {
+        continue;
+      }
+      reports.push(
+        sanitizeOperationalReport({
+          pluginName: plugin.name,
+          report
+        })
+      );
+    } catch (error) {
+      log.error("Trusted plugin operational report failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      reports.push(failedOperationalReport({ nowMs, pluginName: plugin.name }));
+    }
   }
-  return blocks.join("\n\n");
+  return reports;
 }
-var STATIC_SYSTEM_PROMPT = [
-  HEADER,
-  buildIdentitySection(),
-  buildPersonalitySection(),
-  buildWorldSection(),
-  buildBehaviorSection(),
-  buildOutputSection()
-].filter((section) => Boolean(section)).join("\n\n");
-function buildSystemPrompt() {
-  return STATIC_SYSTEM_PROMPT;
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function buildTurnContextPrompt(params) {
-  const includeSessionContext = params.includeSessionContext ?? true;
-  if (!includeSessionContext) {
-    return null;
+function normalizeEnv(value) {
+  if (!isRecord2(value)) {
+    return {};
   }
-  const runtimeSections = [
-    buildCapabilitiesSection({
-      availableSkills: params.availableSkills,
-      activeMcpCatalogs: params.activeMcpCatalogs ?? [],
-      invocation: params.invocation,
-      toolGuidance: params.toolGuidance ?? []
-    }),
-    buildContextSection({
-      requester: params.requester,
-      artifactState: params.artifactState,
-      configuration: params.configuration,
-      invocation: params.invocation
-    }),
-    buildRuntimeSection(params.runtime ?? {})
-  ].filter((section) => Boolean(section));
-  if (runtimeSections.length === 0) {
-    return null;
+  const env = {};
+  for (const [key2, rawValue] of Object.entries(value)) {
+    if (typeof rawValue === "string") {
+      env[key2] = rawValue;
+    }
   }
-  const sections = [
+  return env;
+}
+function createSandboxCapability(sandbox) {
+  return {
+    root: SANDBOX_WORKSPACE_ROOT,
+    juniorRoot: `${SANDBOX_WORKSPACE_ROOT}/.junior`,
+    async readFile(filePath) {
+      return await sandbox.readFileToBuffer({ path: filePath }) ?? null;
+    },
+    async run(input) {
+      const result = await sandbox.runCommand(input);
+      const [stdout, stderr] = await Promise.all([
+        result.stdout(),
+        result.stderr()
+      ]);
+      return {
+        exitCode: result.exitCode,
+        stdout,
+        stderr
+      };
+    },
+    async writeFile(input) {
+      await sandbox.writeFiles([
+        {
+          path: input.path,
+          content: input.content,
+          ...input.mode !== void 0 ? { mode: input.mode } : {}
+        }
+      ]);
+    }
+  };
+}
+function createAgentPluginHookRunner(input = {}) {
+  const loaded = getAgentPlugins();
+  return {
+    async prepareSandbox(sandbox) {
+      const sandboxCapability = createSandboxCapability(sandbox);
+      for (const plugin of loaded) {
+        const hook = plugin.hooks?.sandboxPrepare;
+        if (!hook) {
+          continue;
+        }
+        logInfo(
+          "agent_plugin_hook_sandbox_prepare",
+          {},
+          { "app.plugin.name": plugin.name },
+          "Running agent plugin sandbox prepare hook"
+        );
+        await hook({
+          plugin: { name: plugin.name },
+          log: createAgentPluginLogger(plugin.name),
+          requester: input.requester,
+          sandbox: sandboxCapability
+        });
+      }
+    },
+    async beforeToolExecute(tool) {
+      let nextInput = { ...tool.input };
+      const env = normalizeEnv(nextInput.env);
+      for (const plugin of loaded) {
+        const hook = plugin.hooks?.beforeToolExecute;
+        if (!hook) {
+          continue;
+        }
+        let replacement;
+        let denied;
+        await hook({
+          plugin: { name: plugin.name },
+          log: createAgentPluginLogger(plugin.name),
+          requester: input.requester,
+          tool: {
+            name: tool.name,
+            input: nextInput
+          },
+          env: {
+            get(key2) {
+              return env[key2];
+            },
+            set(key2, value) {
+              env[key2] = value;
+            }
+          },
+          decision: {
+            deny(message) {
+              denied = message;
+            },
+            replaceInput(input2) {
+              replacement = input2;
+            }
+          }
+        });
+        if (denied) {
+          throw new AgentPluginHookDeniedError(denied);
+        }
+        if (replacement !== void 0) {
+          if (!isRecord2(replacement)) {
+            throw new Error(
+              `Plugin "${plugin.name}" replaced tool input with a non-object value`
+            );
+          }
+          nextInput = { ...replacement };
+          Object.assign(env, normalizeEnv(nextInput.env));
+        }
+      }
+      return {
+        input: {
+          ...nextInput,
+          ...Object.keys(env).length > 0 ? { env } : {}
+        },
+        env
+      };
+    }
+  };
+}
+
+// src/handlers/health.ts
+function GET() {
+  return Response.json({
+    status: "ok",
+    service: "junior",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+
+// src/chat/prompt.ts
+import fs from "fs";
+import path from "path";
+
+// src/chat/turn-context-tag.ts
+var TURN_CONTEXT_TAG = "runtime-turn-context";
+
+// src/chat/interruption-marker.ts
+var INTERRUPTED_MARKER = "\n\n[Response interrupted before completion]";
+function getInterruptionMarker() {
+  return INTERRUPTED_MARKER;
+}
+
+// src/chat/slack/status-format.ts
+var SLACK_STATUS_MAX_LENGTH = 50;
+function truncateStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (trimmed.length <= SLACK_STATUS_MAX_LENGTH) {
+    return trimmed;
+  }
+  return `${trimmed.slice(0, SLACK_STATUS_MAX_LENGTH - 3).trimEnd()}...`;
+}
+
+// src/chat/slack/mrkdwn.ts
+function ensureBlockSpacing(text) {
+  const codeBlockPattern = /^```/;
+  const listItemPattern = /^[-*•]\s|^\d+\.\s/;
+  const lines = text.split("\n");
+  const result = [];
+  let inCodeBlock = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isCodeFence = codeBlockPattern.test(line.trimStart());
+    if (isCodeFence) {
+      if (!inCodeBlock) {
+        const prev2 = result.length > 0 ? result[result.length - 1] : void 0;
+        if (prev2 !== void 0 && prev2.trim() !== "") {
+          result.push("");
+        }
+      }
+      inCodeBlock = !inCodeBlock;
+      result.push(line);
+      continue;
+    }
+    if (inCodeBlock) {
+      result.push(line);
+      continue;
+    }
+    const prev = result.length > 0 ? result[result.length - 1] : void 0;
+    if (prev !== void 0 && prev.trim() !== "" && line.trim() !== "" && !(listItemPattern.test(prev.trimStart()) && listItemPattern.test(line.trimStart()))) {
+      result.push("");
+    }
+    result.push(line);
+  }
+  return result.join("\n");
+}
+function renderSlackMrkdwn(text) {
+  let normalized = text.replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "");
+  normalized = ensureBlockSpacing(normalized);
+  return normalized.replace(/\n{3,}/g, "\n\n").trim();
+}
+function normalizeSlackStatusText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  return truncateStatusText(trimmed.replace(/(?:\.\s*)+$/, "").trim());
+}
+
+// src/chat/slack/output.ts
+var MAX_INLINE_CHARS = 2200;
+var MAX_INLINE_LINES = 45;
+var CONTINUED_MARKER = "\n\n[Continued below]";
+function countSlackLines(text) {
+  if (!text) {
+    return 0;
+  }
+  return text.split("\n").length;
+}
+function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return text.length <= maxChars && countSlackLines(text) <= maxLines;
+}
+function findSplitIndex(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text.length;
+  }
+  const bounded = text.slice(0, maxChars);
+  const newlineIndex = bounded.lastIndexOf("\n");
+  if (newlineIndex > 0) {
+    return newlineIndex;
+  }
+  const spaceIndex = bounded.lastIndexOf(" ");
+  if (spaceIndex > 0) {
+    return spaceIndex;
+  }
+  return maxChars;
+}
+function splitByLineBudget(text, maxLines) {
+  if (maxLines <= 0) {
+    return "";
+  }
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) {
+    return text;
+  }
+  return lines.slice(0, maxLines).join("\n");
+}
+function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return {
+    maxChars: Math.max(1, maxChars - suffix.length),
+    maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
+  };
+}
+function forceSplitBudget(text, budget) {
+  const lineCount = countSlackLines(text);
+  return {
+    maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
+    maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
+  };
+}
+function getFenceContinuation(text) {
+  let open;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trimStart();
+    const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+    if (!openerMatch) {
+      continue;
+    }
+    if (!open) {
+      open = {
+        fence: openerMatch[1],
+        openerLine: trimmed
+      };
+      continue;
+    }
+    if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) {
+      open = void 0;
+    }
+  }
+  if (!open) {
+    return null;
+  }
+  return {
+    closeSuffix: text.endsWith("\n") ? open.fence : `
+${open.fence}`,
+    reopenPrefix: `${open.openerLine}
+`
+  };
+}
+function appendSlackSuffix(text, marker) {
+  const carryover = getFenceContinuation(text);
+  return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
+}
+function stripTrailingContinuationMarker(text) {
+  return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -CONTINUED_MARKER.length) : text;
+}
+function takeSlackContinuationChunk(text, budget) {
+  let { prefix, rest } = takeSlackInlinePrefix(text, budget);
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, budget)
+    ));
+  }
+  let carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
+  }
+  const carryoverBudget = reserveInlineBudgetForSuffix(
+    `${carryover.closeSuffix}${CONTINUED_MARKER}`
+  );
+  ({ prefix, rest } = takeSlackInlinePrefix(text, carryoverBudget));
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, carryoverBudget)
+    ));
+  }
+  carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
+  }
+  return {
+    prefix,
+    rest: `${carryover.reopenPrefix}${rest}`
+  };
+}
+function takeSlackContinuationPrefix(text, options) {
+  const budget = {
+    maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
+    maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
+  };
+  const { prefix, rest } = (() => {
+    if (options?.forceSplit) {
+      return takeSlackContinuationChunk(text, budget);
+    }
+    const initial = takeSlackInlinePrefix(text, budget);
+    return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
+  })();
+  return {
+    prefix,
+    renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
+    rest
+  };
+}
+function takeSlackInlinePrefix(text, options) {
+  const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
+  const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
+  const normalized = text.replace(/\r\n?/g, "\n");
+  if (!normalized) {
+    return { prefix: "", rest: "" };
+  }
+  if (fitsInlineBudget(normalized, maxChars, maxLines)) {
+    return { prefix: normalized, rest: "" };
+  }
+  const lineBounded = splitByLineBudget(normalized, maxLines);
+  const cutIndex = findSplitIndex(lineBounded, maxChars);
+  const prefix = lineBounded.slice(0, cutIndex).trimEnd();
+  if (prefix) {
+    return {
+      prefix,
+      rest: normalized.slice(prefix.length).trimStart()
+    };
+  }
+  const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
+  return {
+    prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
+    rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
+  };
+}
+function splitSlackReplyText(text, options) {
+  const normalized = renderSlackMrkdwn(text);
+  if (!normalized) {
+    return [];
+  }
+  const chunks = [];
+  const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+  let remaining = normalized;
+  while (remaining) {
+    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining);
+    if (fitsFinalChunk) {
+      chunks.push(
+        options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining
+      );
+      break;
+    }
+    const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
+      ...continuationBudget,
+      forceSplit: true
+    });
+    chunks.push(renderedPrefix);
+    remaining = rest;
+  }
+  if (chunks.length === 2) {
+    chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
+  }
+  return chunks;
+}
+function getSlackContinuationBudget() {
+  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+}
+function buildSlackOutputMessage(text, files) {
+  const normalized = renderSlackMrkdwn(text);
+  const fileCount = files?.length ?? 0;
+  if (!normalized) {
+    if (fileCount > 0) {
+      return {
+        raw: "",
+        files
+      };
+    }
+    throw new Error(
+      `Slack output normalized to empty content: original_length=${text.length} parsed_length=${normalized.length}`
+    );
+  }
+  return {
+    markdown: normalized,
+    files
+  };
+}
+var slackOutputPolicy = {
+  maxInlineChars: MAX_INLINE_CHARS,
+  maxInlineLines: MAX_INLINE_LINES
+};
+
+// src/chat/xml.ts
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+
+// src/chat/prompt.ts
+var DEFAULT_SOUL = "You are Junior, a practical and concise assistant.";
+function getLoggedMarkdownFiles() {
+  const globalState = globalThis;
+  globalState.__juniorLoggedMarkdownFiles ??= /* @__PURE__ */ new Set();
+  return globalState.__juniorLoggedMarkdownFiles;
+}
+function loadOptionalMarkdownFile(candidates, fileName) {
+  for (const resolved of candidates) {
+    try {
+      const raw = fs.readFileSync(resolved, "utf8").trim();
+      if (raw.length > 0) {
+        const loggedMarkdownFiles = getLoggedMarkdownFiles();
+        const logKey = `${fileName}:${resolved}`;
+        if (!loggedMarkdownFiles.has(logKey)) {
+          loggedMarkdownFiles.add(logKey);
+          logInfo(
+            `${fileName.toLowerCase()}_loaded`,
+            {},
+            {
+              "file.path": resolved
+            },
+            `Loaded ${fileName}`
+          );
+        }
+        return raw;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function loadSoul() {
+  const soul = loadOptionalMarkdownFile(soulPathCandidates(), "SOUL.md");
+  if (soul) {
+    return soul;
+  }
+  logWarn(
+    "soul_load_fallback",
+    {},
+    {
+      "app.file.candidates": soulPathCandidates()
+    },
+    "SOUL.md not found; using built-in default personality"
+  );
+  return DEFAULT_SOUL;
+}
+function loadWorld() {
+  return loadOptionalMarkdownFile(worldPathCandidates(), "WORLD.md");
+}
+var JUNIOR_PERSONALITY = (() => {
+  try {
+    return loadSoul();
+  } catch (error) {
+    logWarn(
+      "soul_load_failed",
+      {},
+      {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to load SOUL.md; using built-in default personality"
+    );
+    return DEFAULT_SOUL;
+  }
+})();
+var JUNIOR_WORLD = (() => {
+  try {
+    return loadWorld();
+  } catch (error) {
+    logWarn(
+      "world_load_failed",
+      {},
+      {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      },
+      "Failed to load WORLD.md; omitting world prompt context"
+    );
+    return null;
+  }
+})();
+function workspaceSkillDir(skillName) {
+  return sandboxSkillDir(skillName);
+}
+function formatConfigurationValue(value) {
+  if (typeof value === "string") {
+    return escapeXml(value);
+  }
+  try {
+    return escapeXml(JSON.stringify(value));
+  } catch {
+    return escapeXml(String(value));
+  }
+}
+function renderRequesterBlock(fields) {
+  const lines = Object.entries(fields).filter(([, value]) => Boolean(value)).map(([key2, value]) => `- ${key2}: ${escapeXml(value)}`);
+  if (lines.length === 0) {
+    return null;
+  }
+  return ["<requester>", ...lines, "</requester>"];
+}
+function renderTag(tag, lines) {
+  return [`<${tag}>`, ...lines, `</${tag}>`];
+}
+function renderTagBlock(tag, content) {
+  return [`<${tag}>`, content, `</${tag}>`].join("\n");
+}
+function formatSkillEntry(skill) {
+  const skillLocation = `${workspaceSkillDir(skill.name)}/SKILL.md`;
+  const lines = [];
+  lines.push("  <skill>");
+  lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+  lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+  lines.push(`    <location>${escapeXml(skillLocation)}</location>`);
+  lines.push("  </skill>");
+  return lines;
+}
+function formatAvailableSkillsForPrompt(skills, invocation) {
+  const autoSelectable = skills.filter(
+    (s) => s.disableModelInvocation !== true
+  );
+  const invokedExplicitOnly = invocation ? skills.filter(
+    (s) => s.disableModelInvocation === true && s.name === invocation.skillName
+  ) : [];
+  const sections = [];
+  if (autoSelectable.length > 0) {
+    const available = [
+      "<available-skills>",
+      "Scan before answering. Load the most specific matching skill; do not answer from memory when a skill fits. A request that names a skill, plugin, provider, or account matching a skill name is a skill match. If none fits, do not load a skill."
+    ];
+    for (const skill of autoSelectable) {
+      available.push(...formatSkillEntry(skill));
+    }
+    available.push("</available-skills>");
+    sections.push(available.join("\n"));
+  }
+  if (invokedExplicitOnly.length > 0) {
+    const userCallable = [
+      "<user-callable-skills>",
+      "The user's current message explicitly references this skill by name. Load it when relevant to the request."
+    ];
+    for (const skill of invokedExplicitOnly) {
+      userCallable.push(...formatSkillEntry(skill));
+    }
+    userCallable.push("</user-callable-skills>");
+    sections.push(userCallable.join("\n"));
+  }
+  return sections.length > 0 ? sections.join("\n") : null;
+}
+function formatActiveMcpCatalogsForPrompt(catalogs) {
+  if (catalogs.length === 0) {
+    return null;
+  }
+  const lines = [
+    "Active MCP provider catalogs are available through `searchMcpTools`. Call it with provider to list descriptors or with query to narrow results, then pass the exact returned `tool_name` to `callMcpTool`. Put provider fields inside `arguments`."
+  ];
+  for (const catalog of catalogs) {
+    lines.push("  <catalog>");
+    lines.push(`    <provider>${escapeXml(catalog.provider)}</provider>`);
+    lines.push(
+      `    <available_tool_count>${catalog.available_tool_count}</available_tool_count>`
+    );
+    lines.push("  </catalog>");
+  }
+  return lines.join("\n");
+}
+function formatToolGuidanceForPrompt(tools) {
+  const guidedTools = tools.filter(
+    (tool) => Boolean(tool.promptSnippet?.trim()) || (tool.promptGuidelines?.length ?? 0) > 0
+  );
+  if (guidedTools.length === 0) {
+    return null;
+  }
+  const lines = [];
+  for (const tool of guidedTools) {
+    lines.push(`  <tool name="${escapeXml(tool.name)}">`);
+    if (tool.promptSnippet?.trim()) {
+      lines.push(`    - ${escapeXml(tool.promptSnippet.trim())}`);
+    }
+    if (tool.promptGuidelines && tool.promptGuidelines.length > 0) {
+      for (const guideline of tool.promptGuidelines) {
+        lines.push(`    - ${escapeXml(guideline)}`);
+      }
+    }
+    lines.push("  </tool>");
+  }
+  return lines.join("\n");
+}
+function formatReferenceFilesLines() {
+  const files = listReferenceFiles();
+  if (files.length === 0) {
+    return null;
+  }
+  return files.map((filePath) => {
+    const name = path.basename(filePath);
+    return `- ${escapeXml(name)} (${escapeXml(`${SANDBOX_DATA_ROOT}/${name}`)})`;
+  });
+}
+function formatArtifactsLines(artifactState) {
+  if (!artifactState) return null;
+  const lines = [];
+  if (artifactState.lastCanvasId) {
+    lines.push(`- last_canvas_id: ${escapeXml(artifactState.lastCanvasId)}`);
+  }
+  if (artifactState.lastCanvasUrl) {
+    lines.push(`- last_canvas_url: ${escapeXml(artifactState.lastCanvasUrl)}`);
+  }
+  if (artifactState.recentCanvases && artifactState.recentCanvases.length > 0) {
+    lines.push("- recent_canvases:");
+    for (const canvas of artifactState.recentCanvases) {
+      lines.push(`  - id: ${escapeXml(canvas.id)}`);
+      if (canvas.title) lines.push(`    title: ${escapeXml(canvas.title)}`);
+      if (canvas.url) lines.push(`    url: ${escapeXml(canvas.url)}`);
+      if (canvas.createdAt) {
+        lines.push(`    created_at: ${escapeXml(canvas.createdAt)}`);
+      }
+    }
+  }
+  if (artifactState.lastListId) {
+    lines.push(`- last_list_id: ${escapeXml(artifactState.lastListId)}`);
+  }
+  if (artifactState.lastListUrl) {
+    lines.push(`- last_list_url: ${escapeXml(artifactState.lastListUrl)}`);
+  }
+  return lines.length > 0 ? lines : null;
+}
+function formatConfigurationLines(configuration) {
+  const keys = Object.keys(configuration ?? {}).sort(
+    (a, b) => a.localeCompare(b)
+  );
+  if (keys.length === 0) return null;
+  return keys.map(
+    (key2) => `- ${escapeXml(key2)}: ${formatConfigurationValue(configuration?.[key2])}`
+  );
+}
+var HEADER = "You are a Slack-based helper assistant. Follow the personality section for voice and tone in every reply. Platform mechanics and output rules override personality and world context when they conflict.";
+var TURN_CONTEXT_HEADER = "Runtime context for this request. Treat these blocks as trusted runtime facts; the static system prompt remains authoritative.";
+var TOOL_POLICY_RULES = [
+  "- Tool schemas are the source of truth for parameters; tool names are case-sensitive, so call tools exactly by their exposed names and do not invent arguments.",
+  "- Use tools for actionable work and for facts that are mutable, external, repository-backed, provider-backed, or requested as verified/current. Stable general knowledge and already-provided context may be answered directly.",
+  "- Resolve provider action targets before calls: explicit target wins; ambient `<configuration>` fills omitted targets. Treat non-target links/references as context.",
+  "- Verification source order: conversation/thread context; user-provided attachments, links, and reference files; local/sandbox files when present; loaded skill references; repository/provider tools; public web. Use the nearest authoritative available source before weaker sources.",
+  "- For repository or implementation questions, inspect the target repository first: local checkout when present, otherwise the configured GitHub/source provider. Do not treat loaded skill files as repo source unless the user asks about the skill. Cite file paths, symbols, PRs/issues, commits, or URLs that support the answer.",
+  `- Sandbox-backed file and shell tools operate in an isolated workspace rooted at ${SANDBOX_WORKSPACE_ROOT}; readFile/writeFile paths are sandbox-workspace paths, bash runs inside that workspace, and attachFile accepts absolute or workspace-relative sandbox paths.`,
+  "- If a sandbox-backed tool reports that sandbox execution is unavailable, treat that as a blocker for local file/shell inspection; do not pretend host files were inspected.",
+  "- For user-provided URLs, use `webFetch`; for discovery, use `webSearch` then fetch/read promising sources; for current time/date context, use `systemTime`.",
+  "- If the first result is empty, stale, ambiguous, or incomplete, try a focused alternate query, path, command, or source before concluding the answer cannot be verified."
+];
+var TOOL_CALL_STYLE_RULES = [
+  "- For routine low-risk tool use, call the tool directly without narrating the obvious step first.",
+  "- Briefly narrate only when it helps the user understand multi-step work, sensitive actions, destructive actions, or a notable change in approach.",
+  "- When a first-class tool exists for an action, use it directly instead of asking the user to run an equivalent command, slash command, or manual lookup.",
+  "- Keep tool-call explanations separate from final answers; final answers should report results, evidence, or blockers."
+];
+var SKILL_POLICY_RULES = [
+  "- Only load skills listed in `<available-skills>`, `<user-callable-skills>`, or named by `<explicit-skill-trigger>`. Never guess or invent a skill name.",
+  "- Load one skill at a time. After `loadSkill`, follow the instructions returned by that tool result."
+];
+var EXECUTION_CONTRACT_RULES = [
+  "- Actionable request: act in this turn.",
+  "- Continue until done or genuinely blocked. Do not finish with a plan, promise, or offer to check next when an available tool or source can move the request forward.",
+  "- Completion means the final answer covers the user's actual ask, including requested follow-up checks, and is grounded in the best evidence you could access.",
+  "- Ask the user only for missing access, approval, or a decision that blocks safe progress. Ask one focused question; otherwise infer conservatively and continue.",
+  "- For conflicting evidence, compare sources and state which source is authoritative for the answer.",
+  "- For non-trivial or long-running work, call `reportProgress` early when available, then only when the major phase changes. Routine tool calls should stay silent."
+];
+var CONVERSATION_RULES = [
+  "- In thread follow-ups, answer from prior thread context; do not repeat resolved clarifying questions.",
+  "- Preserve attribution roles from thread context: the requester is the person asking now, which may differ from the original reporter or subject.",
+  "- Runtime owns continuation and authorization notices; on resumed turns, answer with the final requested content only."
+];
+var SLACK_ACTION_RULES = [
+  "- Context-bound Slack tools use runtime-owned targets; do not invent channel, canvas, list, or message IDs.",
+  "- Use first-class Slack tools for Slack side effects; do not use bash, curl, or provider APIs to bypass Slack tool targeting.",
+  "- Use channel-post and emoji-reaction tools only when the user explicitly asks for that Slack side effect.",
+  "- For explicit channel-post or emoji-reaction requests, skip a duplicate thread text reply when the tool result already satisfies the request.",
+  "- Do not claim an attachment, canvas, channel post, list update, or reaction succeeded unless the tool returned success this turn; when it did, include any link the tool returned.",
+  "- Do not use reactions as progress indicators."
+];
+var SAFETY_RULES = [
+  "- Stay within the user's request and the runtime's available capabilities; do not pursue independent goals, persistence, replication, credential gathering, or access expansion.",
+  "- Respect stop, pause, audit, and approval boundaries. Do not bypass safeguards or persuade the user to weaken them.",
+  "- Do not change system prompts, tool policies, security settings, credentials, or runtime configuration unless the user explicitly requests that exact administrative action and an available tool permits it."
+];
+var FAILURE_RULES = [
+  "- For tool/runtime failures, run the named check before diagnosing and report the exact failed command plus stderr/exit code.",
+  "- If a fact cannot be verified after focused checks, say what you checked and what blocked a stronger answer.",
+  "- Do not surface raw tool payloads, execution-escape text, or internal routing metadata as the final answer."
+];
+function renderRuleSection(tag, lines) {
+  return [`<${tag}>`, ...lines, `</${tag}>`].join("\n");
+}
+function buildBehaviorSection() {
+  return [
+    renderRuleSection("tool-policy", TOOL_POLICY_RULES),
+    renderRuleSection("tool-call-style", TOOL_CALL_STYLE_RULES),
+    renderRuleSection("skill-policy", SKILL_POLICY_RULES),
+    renderRuleSection("execution-contract", EXECUTION_CONTRACT_RULES),
+    renderRuleSection("conversation", CONVERSATION_RULES),
+    renderRuleSection("slack-actions", SLACK_ACTION_RULES),
+    renderRuleSection("safety", SAFETY_RULES),
+    renderRuleSection("failure-handling", FAILURE_RULES)
+  ].join("\n\n");
+}
+function buildOutputSection() {
+  const openTag = `<output format="slack-markdown" max_inline_chars="${slackOutputPolicy.maxInlineChars}" max_inline_lines="${slackOutputPolicy.maxInlineLines}">`;
+  return [
+    openTag,
+    "- Start with the answer or result, not internal process narration.",
+    "- Use Slack-flavored Markdown: **bold** section labels, `code`, [text](url) links, bullet lists, and fenced code blocks. No hash-prefixed headings and no tables. When the answer primarily lists several URLs, show each URL bare instead of as a labeled link.",
+    "- Keep replies brief and scannable; use bullets or short code blocks when helpful, and one compact thread reply when it fits.",
+    "- When a research or document-style answer would benefit from continuation, multiple sections, or future reference value, create a Slack canvas and keep the thread reply to one or two short sentences plus the link; do not recap the canvas contents.",
+    "- Unless a successful Slack side-effect tool intentionally satisfied the request by itself, end every turn with a final user-facing markdown response.",
+    "</output>"
+  ].join("\n");
+}
+function buildIdentitySection() {
+  return [
+    "# Identity",
+    `Your Slack username is \`${botConfig.userName}\`.`
+  ].join("\n");
+}
+function buildPersonalitySection() {
+  return ["# Personality", JUNIOR_PERSONALITY.trim()].join("\n");
+}
+function buildWorldSection() {
+  if (!JUNIOR_WORLD) {
+    return null;
+  }
+  return ["# World", JUNIOR_WORLD.trim()].join("\n");
+}
+function buildRuntimeSection(params) {
+  const lines = [
+    params.conversationId ? `- gen_ai.conversation.id: ${escapeXml(params.conversationId)}` : "",
+    params.slackConversation?.type ? `- slack.conversation.type: ${escapeXml(params.slackConversation.type)}` : "",
+    params.slackConversation?.name ? `- slack.conversation.name: ${escapeXml(params.slackConversation.name)}` : ""
+  ].filter(Boolean);
+  if (lines.length === 0) {
+    return null;
+  }
+  return renderTagBlock("runtime", lines.join("\n"));
+}
+function buildContextSection(params) {
+  const blocks = [];
+  const referenceLines = formatReferenceFilesLines();
+  if (referenceLines) {
+    blocks.push(
+      renderTag("reference-files", [
+        "Additional reference documents available in the sandbox. Read them with `readFile` when relevant.",
+        ...referenceLines
+      ])
+    );
+  }
+  const requesterLines = renderRequesterBlock({
+    full_name: params.requester?.fullName,
+    user_name: params.requester?.userName,
+    user_id: params.requester?.userId
+  });
+  if (requesterLines) {
+    blocks.push(requesterLines);
+  }
+  const artifactLines = formatArtifactsLines(params.artifactState);
+  if (artifactLines) {
+    blocks.push(renderTag("artifacts", artifactLines));
+  }
+  const configLines = formatConfigurationLines(params.configuration);
+  if (configLines) {
+    blocks.push(
+      renderTag("configuration", [
+        "Ambient provider defaults; explicit targets win. Run `jr-rpc config get|set|unset|list` as standalone bash commands; do not chain with `cd`, `&&`, pipes, or provider commands.",
+        ...configLines
+      ])
+    );
+  }
+  if (params.invocation) {
+    blocks.push(
+      renderTag("explicit-skill-trigger", [
+        "Treat this skill as selected. Load it unless the tool says it is unavailable.",
+        `/${escapeXml(params.invocation.skillName)}`
+      ])
+    );
+  }
+  const body = blocks.map((block) => block.join("\n")).join("\n\n");
+  if (!body) {
+    return null;
+  }
+  return renderTagBlock("context", body);
+}
+function buildCapabilitiesSection(params) {
+  const blocks = [];
+  const availableSkills = formatAvailableSkillsForPrompt(
+    params.availableSkills,
+    params.invocation
+  );
+  if (availableSkills) {
+    blocks.push(availableSkills);
+  }
+  const activeCatalogs = formatActiveMcpCatalogsForPrompt(
+    params.activeMcpCatalogs
+  );
+  if (activeCatalogs) {
+    blocks.push(renderTagBlock("active-mcp-catalogs", activeCatalogs));
+  }
+  const toolGuidance = formatToolGuidanceForPrompt(params.toolGuidance ?? []);
+  if (toolGuidance) {
+    blocks.push(renderTagBlock("tool-guidance", toolGuidance));
+  }
+  if (blocks.length === 0) {
+    return null;
+  }
+  return blocks.join("\n\n");
+}
+var STATIC_SYSTEM_PROMPT = [
+  HEADER,
+  buildIdentitySection(),
+  buildPersonalitySection(),
+  buildWorldSection(),
+  buildBehaviorSection(),
+  buildOutputSection()
+].filter((section) => Boolean(section)).join("\n\n");
+function buildSystemPrompt() {
+  return STATIC_SYSTEM_PROMPT;
+}
+function buildTurnContextPrompt(params) {
+  const includeSessionContext = params.includeSessionContext ?? true;
+  if (!includeSessionContext) {
+    return null;
+  }
+  const runtimeSections = [
+    buildCapabilitiesSection({
+      availableSkills: params.availableSkills,
+      activeMcpCatalogs: params.activeMcpCatalogs ?? [],
+      invocation: params.invocation,
+      toolGuidance: params.toolGuidance ?? []
+    }),
+    buildContextSection({
+      requester: params.requester,
+      artifactState: params.artifactState,
+      configuration: params.configuration,
+      invocation: params.invocation
+    }),
+    buildRuntimeSection(params.runtime ?? {})
+  ].filter((section) => Boolean(section));
+  if (runtimeSections.length === 0) {
+    return null;
+  }
+  const sections = [
     `<${TURN_CONTEXT_TAG}>`,
     TURN_CONTEXT_HEADER,
     "The current user instruction appears after this block in the same message.",
@@ -1243,6 +2279,9 @@ function parseAgentTurnSessionStatus(parsed) {
   }
   return void 0;
 }
+function parseAgentTurnSurface(value) {
+  return value === "slack" || value === "api" || value === "scheduler" || value === "internal" ? value : void 0;
+}
 function parseAgentTurnSessionFields(parsed) {
   const status = parseAgentTurnSessionStatus(parsed);
   if (!status) {
@@ -1261,6 +2300,7 @@ function parseAgentTurnSessionFields(parsed) {
   const logSessionId = typeof parsed.logSessionId === "string" ? parsed.logSessionId : void 0;
   const requester = parseAgentTurnRequester(parsed.requester);
   const startedAtMs = toFiniteNonNegativeNumber(parsed.startedAtMs);
+  const surface = parseAgentTurnSurface(parsed.surface);
   if (typeof conversationId !== "string" || typeof sessionId !== "string" || sliceId === void 0 || version === void 0 || updatedAtMs === void 0) {
     return void 0;
   }
@@ -1287,6 +2327,7 @@ function parseAgentTurnSessionFields(parsed) {
     ...parsed.resumeReason === "timeout" || parsed.resumeReason === "auth" || parsed.resumeReason === "yield" ? { resumeReason: parsed.resumeReason } : {},
     ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
     ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {},
+    ...surface ? { surface } : {},
     ...typeof parsed.traceId === "string" ? { traceId: parsed.traceId } : {}
   };
 }
@@ -1372,6 +2413,7 @@ function materializeAgentTurnSessionRecord(stored, piMessages) {
     ...stored.loadedSkillNames ? { loadedSkillNames: stored.loadedSkillNames } : {},
     ...stored.requester ? { requester: stored.requester } : {},
     ...stored.resumedFromSliceId !== void 0 ? { resumedFromSliceId: stored.resumedFromSliceId } : {},
+    ...stored.surface ? { surface: stored.surface } : {},
     ...stored.traceId ? { traceId: stored.traceId } : {}
   };
 }
@@ -1437,6 +2479,7 @@ function buildStoredRecord(args) {
     ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
     ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
     ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {},
+    ...args.surface ? { surface: args.surface } : {},
     ...args.traceId ? { traceId: args.traceId } : {}
   };
 }
@@ -1486,6 +2529,7 @@ async function updateAgentTurnSessionState(args) {
       ...args.existing.requester ? { requester: args.existing.requester } : {},
       ...args.existing.resumeReason ? { resumeReason: args.existing.resumeReason } : {},
       ...args.existing.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.existing.resumedFromSliceId } : {},
+      ...args.existing.surface ? { surface: args.existing.surface } : {},
       ...args.existing.traceId ? { traceId: args.existing.traceId } : {},
       ...args.errorMessage ?? args.existing.errorMessage ? { errorMessage: args.errorMessage ?? args.existing.errorMessage } : {}
     })
@@ -1526,6 +2570,7 @@ async function upsertAgentTurnSessionRecord(args) {
       ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
       ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
       ...args.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.resumedFromSliceId } : {},
+      ...args.surface ?? existingRecord?.surface ? { surface: args.surface ?? existingRecord?.surface } : {},
       ...args.traceId ?? existingRecord?.traceId ? { traceId: args.traceId ?? existingRecord?.traceId } : {}
     })
   });
@@ -1560,6 +2605,7 @@ async function recordAgentTurnSessionSummary(args) {
         )
       } : existing?.loadedSkillNames ? { loadedSkillNames: existing.loadedSkillNames } : {},
       ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+      ...args.surface ?? existing?.surface ? { surface: args.surface ?? existing?.surface } : {},
       ...args.traceId ?? existing?.traceId ? { traceId: args.traceId ?? existing?.traceId } : {}
     },
     ttlMs
@@ -1573,380 +2619,111 @@ async function readAgentTurnSessionSummariesFromIndex(key2) {
   for (const value of [...values].reverse()) {
     const summary = parseAgentTurnSessionSummary(value);
     if (!summary) {
-      continue;
-    }
-    const key3 = `${summary.conversationId}:${summary.sessionId}`;
-    if (!summaries.has(key3)) {
-      summaries.set(key3, summary);
-    }
-  }
-  return [...summaries.values()].sort(
-    (left, right) => right.updatedAtMs - left.updatedAtMs
-  );
-}
-async function listAgentTurnSessionSummaries(limit = 50) {
-  return (await readAgentTurnSessionSummariesFromIndex(AGENT_TURN_SESSION_INDEX_KEY)).slice(0, Math.max(0, Math.floor(limit)));
-}
-async function listAgentTurnSessionSummariesForConversation(conversationId) {
-  const summaries = await readAgentTurnSessionSummariesFromIndex(
-    agentTurnSessionConversationIndexKey(conversationId)
-  );
-  if (summaries.length > 0) {
-    return summaries;
-  }
-  return (await readAgentTurnSessionSummariesFromIndex(AGENT_TURN_SESSION_INDEX_KEY)).filter((summary) => summary.conversationId === conversationId);
-}
-async function abandonAgentTurnSessionRecord(args) {
-  const existing = await getAgentTurnSessionRecord(
-    args.conversationId,
-    args.sessionId
-  );
-  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned") {
-    return void 0;
-  }
-  return await updateAgentTurnSessionState({
-    existing,
-    state: "abandoned",
-    errorMessage: args.errorMessage ?? existing.errorMessage
-  });
-}
-async function failAgentTurnSessionRecord(args) {
-  const existing = await getAgentTurnSessionRecord(
-    args.conversationId,
-    args.sessionId
-  );
-  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
-    return void 0;
-  }
-  return await updateAgentTurnSessionState({
-    existing,
-    state: "failed",
-    errorMessage: args.errorMessage ?? existing.errorMessage
-  });
-}
-
-// src/chat/sentry-links.ts
-function getSentryOrgSlug() {
-  const slug = process.env.SENTRY_ORG_SLUG?.trim();
-  return slug || void 0;
-}
-function isSentrySaasDsnHost(host) {
-  return host === "sentry.io" || host.endsWith(".sentry.io");
-}
-function buildSentryWebBaseUrl(dsn) {
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return "https://sentry.io";
-  }
-  const port = dsn.port ? `:${dsn.port}` : "";
-  const path2 = dsn.path ? `/${dsn.path}` : "";
-  return `${dsn.protocol}://${dsn.host}${port}${path2}`;
-}
-function buildSentryConversationUrl(conversationId) {
-  const client2 = sentry_exports.getClient();
-  const dsn = client2?.getDsn();
-  if (!dsn?.host || !dsn.projectId) {
-    return void 0;
-  }
-  const orgSlug = getSentryOrgSlug();
-  if (!orgSlug) {
-    return void 0;
-  }
-  const encodedId = encodeURIComponent(conversationId);
-  const params = new URLSearchParams();
-  params.set("project", dsn.projectId);
-  const path2 = `explore/conversations/${encodedId}/?${params.toString()}`;
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${path2}`;
-  }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path2}`;
-}
-function buildSentryTraceUrl(traceId) {
-  const client2 = sentry_exports.getClient();
-  const dsn = client2?.getDsn();
-  if (!dsn?.host || !dsn.projectId) {
-    return void 0;
-  }
-  const orgSlug = getSentryOrgSlug();
-  if (!orgSlug) {
-    return void 0;
-  }
-  const encodedTraceId = encodeURIComponent(traceId);
-  const params = new URLSearchParams();
-  params.set("project", dsn.projectId);
-  const path2 = `performance/trace/${encodedTraceId}/?${params.toString()}`;
-  if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${path2}`;
-  }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path2}`;
-}
-
-// src/chat/slack/client.ts
-import { WebClient } from "@slack/web-api";
-var SlackActionError = class extends Error {
-  code;
-  apiError;
-  needed;
-  provided;
-  statusCode;
-  requestId;
-  errorData;
-  retryAfterSeconds;
-  detail;
-  detailLine;
-  detailRule;
-  constructor(message, code, options = {}) {
-    super(message);
-    this.name = "SlackActionError";
-    this.code = code;
-    this.apiError = options.apiError;
-    this.needed = options.needed;
-    this.provided = options.provided;
-    this.statusCode = options.statusCode;
-    this.requestId = options.requestId;
-    this.errorData = options.errorData;
-    this.retryAfterSeconds = options.retryAfterSeconds;
-    this.detail = options.detail;
-    this.detailLine = options.detailLine;
-    this.detailRule = options.detailRule;
-  }
-};
-function serializeSlackErrorData(data) {
-  if (!data || typeof data !== "object") {
-    return void 0;
-  }
-  const filtered = Object.fromEntries(
-    Object.entries(data).filter(
-      ([key2]) => key2 !== "error"
-    )
-  );
-  if (Object.keys(filtered).length === 0) {
-    return void 0;
-  }
-  try {
-    const serialized = JSON.stringify(filtered);
-    return serialized.length <= 600 ? serialized : `${serialized.slice(0, 597)}...`;
-  } catch {
-    return void 0;
-  }
-}
-function getHeaderString(headers, name) {
-  if (!headers || typeof headers !== "object") {
-    return void 0;
-  }
-  const key2 = name.toLowerCase();
-  const entries = headers;
-  for (const [entryKey, value] of Object.entries(entries)) {
-    if (entryKey.toLowerCase() !== key2) continue;
-    if (typeof value === "string") return value;
-    if (Array.isArray(value)) {
-      const first = value.find((entry) => typeof entry === "string");
-      return typeof first === "string" ? first : void 0;
-    }
-  }
-  return void 0;
-}
-function parseSlackCanvasDetail(detail) {
-  if (typeof detail !== "string") {
-    return {};
-  }
-  const trimmed = detail.trim();
-  if (!trimmed) {
-    return {};
-  }
-  const parsed = {
-    detail: trimmed
-  };
-  const lineMatch = trimmed.match(/line\s+(\d+):/i);
-  if (lineMatch) {
-    const line = Number.parseInt(lineMatch[1] ?? "", 10);
-    if (Number.isFinite(line)) {
-      parsed.detailLine = line;
+      continue;
+    }
+    const key3 = `${summary.conversationId}:${summary.sessionId}`;
+    if (!summaries.has(key3)) {
+      summaries.set(key3, summary);
     }
   }
-  if (/unsupported heading depth/i.test(trimmed)) {
-    parsed.detailRule = "unsupported_heading_depth";
-  }
-  return parsed;
+  return [...summaries.values()].sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs
+  );
 }
-var client = null;
-function normalizeSlackConversationId(channelId) {
-  if (!channelId) return void 0;
-  const trimmed = channelId.trim();
-  if (!trimmed) return void 0;
-  if (!trimmed.startsWith("slack:")) {
-    return trimmed;
-  }
-  const parts = trimmed.split(":");
-  return parts[1]?.trim() || void 0;
+async function listAgentTurnSessionSummaries(limit = 50) {
+  return (await readAgentTurnSessionSummariesFromIndex(AGENT_TURN_SESSION_INDEX_KEY)).slice(0, Math.max(0, Math.floor(limit)));
 }
-function getClient2() {
-  if (client) return client;
-  const token = getSlackBotToken();
-  if (!token) {
-    throw new SlackActionError(
-      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack canvas/list actions in this service",
-      "missing_token"
-    );
+async function listAgentTurnSessionSummariesForConversation(conversationId) {
+  const summaries = await readAgentTurnSessionSummariesFromIndex(
+    agentTurnSessionConversationIndexKey(conversationId)
+  );
+  if (summaries.length > 0) {
+    return summaries;
   }
-  client = new WebClient(token);
-  return client;
+  return (await readAgentTurnSessionSummariesFromIndex(AGENT_TURN_SESSION_INDEX_KEY)).filter((summary) => summary.conversationId === conversationId);
 }
-function mapSlackError(error) {
-  if (error instanceof SlackActionError) {
-    return error;
-  }
-  const candidate = error;
-  const apiError = candidate.data?.error;
-  const message = candidate.message ?? "Slack action failed";
-  const baseOptions = {
-    apiError,
-    statusCode: candidate.statusCode,
-    requestId: getHeaderString(candidate.headers, "x-slack-req-id"),
-    errorData: serializeSlackErrorData(candidate.data),
-    ...parseSlackCanvasDetail(candidate.data?.detail)
-  };
-  if (apiError === "missing_scope") {
-    return new SlackActionError(message, "missing_scope", {
-      ...baseOptions,
-      needed: candidate.data?.needed,
-      provided: candidate.data?.provided
-    });
-  }
-  if (apiError === "not_in_channel") {
-    return new SlackActionError(message, "not_in_channel", baseOptions);
-  }
-  if (apiError === "already_reacted") {
-    return new SlackActionError(message, "already_reacted", baseOptions);
-  }
-  if (apiError === "no_reaction") {
-    return new SlackActionError(message, "no_reaction", baseOptions);
-  }
-  if (apiError === "invalid_arguments") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "invalid_cursor") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "invalid_name") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "not_found" || apiError === "channel_not_found" || apiError === "message_not_found") {
-    return new SlackActionError(message, "not_found", baseOptions);
-  }
-  if (apiError === "feature_not_enabled" || apiError === "not_allowed_token_type") {
-    return new SlackActionError(message, "feature_unavailable", baseOptions);
-  }
-  if (apiError === "canvas_creation_failed") {
-    return new SlackActionError(message, "canvas_creation_failed", baseOptions);
-  }
-  if (apiError === "canvas_editing_failed") {
-    return new SlackActionError(message, "canvas_editing_failed", baseOptions);
-  }
-  if (candidate.code === "slack_webapi_rate_limited_error" || candidate.statusCode === 429) {
-    return new SlackActionError(message, "rate_limited", {
-      ...baseOptions,
-      retryAfterSeconds: candidate.retryAfter
-    });
+async function abandonAgentTurnSessionRecord(args) {
+  const existing = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned") {
+    return void 0;
   }
-  return new SlackActionError(message, "internal_error", baseOptions);
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return await updateAgentTurnSessionState({
+    existing,
+    state: "abandoned",
+    errorMessage: args.errorMessage ?? existing.errorMessage
+  });
 }
-async function withSlackRetries(task, maxAttempts = 3, context = {}) {
-  let attempt = 0;
-  while (attempt < maxAttempts) {
-    attempt += 1;
-    try {
-      return await task();
-    } catch (error) {
-      const mapped = mapSlackError(error);
-      const isRetryable = mapped.code === "rate_limited";
-      const baseLogAttributes = {
-        "app.slack.action": context.action ?? "unknown",
-        "app.slack.error_code": mapped.code,
-        ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : {},
-        ...mapped.detail ? { "app.slack.detail": mapped.detail } : {},
-        ...mapped.detailLine !== void 0 ? { "app.slack.detail_line": mapped.detailLine } : {},
-        ...mapped.detailRule ? { "app.slack.detail_rule": mapped.detailRule } : {},
-        ...mapped.requestId ? { "app.slack.request_id": mapped.requestId } : {},
-        ...mapped.statusCode !== void 0 ? { "http.response.status_code": mapped.statusCode } : {},
-        ...context.attributes ?? {}
-      };
-      if (!isRetryable || attempt >= maxAttempts) {
-        logWarn(
-          "slack_action_failed",
-          {},
-          {
-            ...baseLogAttributes,
-            ...mapped.errorData ? { "app.slack.error_data": mapped.errorData } : {}
-          },
-          "Slack action failed"
-        );
-        throw mapped;
-      }
-      logWarn(
-        "slack_action_retrying",
-        {},
-        {
-          ...baseLogAttributes,
-          "app.slack.retry_attempt": attempt
-        },
-        "Retrying Slack action after transient failure"
-      );
-      const retryAfterMs = mapped.code === "rate_limited" && mapped.retryAfterSeconds && mapped.retryAfterSeconds > 0 ? mapped.retryAfterSeconds * 1e3 : void 0;
-      const backoffMs = Math.min(2e3, 250 * 2 ** (attempt - 1));
-      await sleep(retryAfterMs ?? backoffMs);
-    }
-  }
-  throw new SlackActionError(
-    "Slack action exhausted retries",
-    "internal_error"
+async function failAgentTurnSessionRecord(args) {
+  const existing = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
   );
+  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
+    return void 0;
+  }
+  return await updateAgentTurnSessionState({
+    existing,
+    state: "failed",
+    errorMessage: args.errorMessage ?? existing.errorMessage
+  });
 }
-function getSlackClient() {
-  return getClient2();
-}
-function isDmChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  return Boolean(normalized && normalized.startsWith("D"));
+
+// src/chat/sentry-links.ts
+function getSentryOrgSlug() {
+  const slug = process.env.SENTRY_ORG_SLUG?.trim();
+  return slug || void 0;
 }
-function isConversationScopedChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) return false;
-  return normalized.startsWith("C") || normalized.startsWith("G") || normalized.startsWith("D");
+function isSentrySaasDsnHost(host) {
+  return host === "sentry.io" || host.endsWith(".sentry.io");
 }
-function isConversationChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) return false;
-  return normalized.startsWith("C") || normalized.startsWith("G");
+function buildSentryWebBaseUrl(dsn) {
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return "https://sentry.io";
+  }
+  const port = dsn.port ? `:${dsn.port}` : "";
+  const path2 = dsn.path ? `/${dsn.path}` : "";
+  return `${dsn.protocol}://${dsn.host}${port}${path2}`;
 }
-async function getFilePermalink(fileId) {
-  const client2 = getClient2();
-  const response = await withSlackRetries(
-    () => client2.files.info({
-      file: fileId
-    })
-  );
-  return response.file?.permalink;
+function buildSentryConversationUrl(conversationId) {
+  const client2 = sentry_exports.getClient();
+  const dsn = client2?.getDsn();
+  if (!dsn?.host || !dsn.projectId) {
+    return void 0;
+  }
+  const orgSlug = getSentryOrgSlug();
+  if (!orgSlug) {
+    return void 0;
+  }
+  const encodedId = encodeURIComponent(conversationId);
+  const params = new URLSearchParams();
+  params.set("project", dsn.projectId);
+  const path2 = `explore/conversations/${encodedId}/?${params.toString()}`;
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return `https://${orgSlug}.sentry.io/${path2}`;
+  }
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path2}`;
 }
-async function downloadPrivateSlackFile(url) {
-  const token = getSlackBotToken();
-  if (!token) {
-    throw new SlackActionError(
-      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack file downloads in this service",
-      "missing_token"
-    );
+function buildSentryTraceUrl(traceId) {
+  const client2 = sentry_exports.getClient();
+  const dsn = client2?.getDsn();
+  if (!dsn?.host || !dsn.projectId) {
+    return void 0;
   }
-  const response = await fetch(url, {
-    headers: {
-      Authorization: `Bearer ${token}`
-    }
-  });
-  if (!response.ok) {
-    throw new Error(`Slack file download failed: ${response.status}`);
+  const orgSlug = getSentryOrgSlug();
+  if (!orgSlug) {
+    return void 0;
   }
-  return Buffer.from(await response.arrayBuffer());
+  const encodedTraceId = encodeURIComponent(traceId);
+  const params = new URLSearchParams();
+  params.set("project", dsn.projectId);
+  const path2 = `performance/trace/${encodedTraceId}/?${params.toString()}`;
+  if (isSentrySaasDsnHost(dsn.host)) {
+    return `https://${orgSlug}.sentry.io/${path2}`;
+  }
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path2}`;
 }
 
 // src/chat/slack/conversation-context.ts
@@ -2018,6 +2795,8 @@ function formatSlackConversationRedactedLabel(context) {
 }
 
 export {
+  createAgentPluginLogger,
+  createPluginState,
   SlackActionError,
   getHeaderString,
   normalizeSlackConversationId,
@@ -2028,6 +2807,16 @@ export {
   isConversationChannel,
   getFilePermalink,
   downloadPrivateSlackFile,
+  bindSlackDirectCredentialSubject,
+  verifySlackDirectCredentialSubject,
+  validateAgentPlugins,
+  setAgentPlugins,
+  getAgentPlugins,
+  getAgentPluginTools,
+  getAgentPluginRoutes,
+  getAgentPluginSlackConversationLink,
+  getAgentPluginOperationalReports,
+  createAgentPluginHookRunner,
   GET,
   TURN_CONTEXT_TAG,
   getInterruptionMarker,