@sentry/junior 0.61.0 → 0.63.0

package/dist/{chunk-I4FDGMFI.js → chunk-ITZ2F7UE.js}

@@ -1,14 +1,25 @@
 import {
+  SANDBOX_DATA_ROOT,
+  SANDBOX_WORKSPACE_ROOT,
+  botConfig,
   getChatConfig,
   getConnectedStateContext,
-  getStateAdapter
-} from "./chunk-FKEKRBUB.js";
+  getStateAdapter,
+  sandboxSkillDir
+} from "./chunk-PEF6UXTY.js";
 import {
-  isRecord
+  isRecord,
+  logInfo,
+  logWarn
 } from "./chunk-H652GMDH.js";
 import {
   sentry_exports
 } from "./chunk-Z3YD6NHK.js";
+import {
+  listReferenceFiles,
+  soulPathCandidates,
+  worldPathCandidates
+} from "./chunk-5LUISFEY.js";
 
 // src/handlers/health.ts
 function GET() {
@@ -19,6 +30,753 @@ function GET() {
   });
 }
 
+// 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)}` : ""
+  ].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.",
+    ...runtimeSections,
+    `</${TURN_CONTEXT_TAG}>`
+  ].filter((section) => Boolean(section));
+  return sections.join("\n\n");
+}
+
 // src/chat/state/turn-session.ts
 import { THREAD_STATE_TTL_MS } from "chat";
 
@@ -888,8 +1646,8 @@ function buildSentryWebBaseUrl(dsn) {
     return "https://sentry.io";
   }
   const port = dsn.port ? `:${dsn.port}` : "";
-  const path = dsn.path ? `/${dsn.path}` : "";
-  return `${dsn.protocol}://${dsn.host}${port}${path}`;
+  const path2 = dsn.path ? `/${dsn.path}` : "";
+  return `${dsn.protocol}://${dsn.host}${port}${path2}`;
 }
 function buildSentryConversationUrl(conversationId) {
   const client = sentry_exports.getClient();
@@ -904,11 +1662,11 @@ function buildSentryConversationUrl(conversationId) {
   const encodedId = encodeURIComponent(conversationId);
   const params = new URLSearchParams();
   params.set("project", dsn.projectId);
-  const path = `explore/conversations/${encodedId}/?${params.toString()}`;
+  const path2 = `explore/conversations/${encodedId}/?${params.toString()}`;
   if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${path}`;
+    return `https://${orgSlug}.sentry.io/${path2}`;
   }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path2}`;
 }
 function buildSentryTraceUrl(traceId) {
   const client = sentry_exports.getClient();
@@ -923,15 +1681,25 @@ function buildSentryTraceUrl(traceId) {
   const encodedTraceId = encodeURIComponent(traceId);
   const params = new URLSearchParams();
   params.set("project", dsn.projectId);
-  const path = `performance/trace/${encodedTraceId}/?${params.toString()}`;
+  const path2 = `performance/trace/${encodedTraceId}/?${params.toString()}`;
   if (isSentrySaasDsnHost(dsn.host)) {
-    return `https://${orgSlug}.sentry.io/${path}`;
+    return `https://${orgSlug}.sentry.io/${path2}`;
   }
-  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
+  return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path2}`;
 }
 
 export {
   GET,
+  TURN_CONTEXT_TAG,
+  getInterruptionMarker,
+  truncateStatusText,
+  normalizeSlackStatusText,
+  splitSlackReplyText,
+  buildSlackOutputMessage,
+  escapeXml,
+  JUNIOR_PERSONALITY,
+  buildSystemPrompt,
+  buildTurnContextPrompt,
   loadProjection,
   loadConnectedMcpProviders,
   recordMcpProviderConnected,