@sentry/junior 0.147.0 → 0.149.0

package/dist/{chunk-AIOK6LAG.js → chunk-EW2LNCRL.js}

@@ -1,11 +1,6 @@
 import {
-  JUNIOR_NATIVE_EVENT_NAMESPACE,
-  ToolInputError,
-  addAgentTurnUsage,
-  agentsInstructionsUpdatedEvent,
-  authenticationLinkedEvent,
-  authenticationUnlinkedEvent
-} from "./chunk-HLXXQI5Q.js";
+  usageSchema
+} from "./chunk-PDO5BLNM.js";
 import {
   agentHistoryItemSchema,
   bindProviderConversation,
@@ -18,7 +13,7 @@ import {
   instructionProvenanceFor,
   sanitizePostgresJson,
   withConversationEventLock
-} from "./chunk-YSB2N563.js";
+} from "./chunk-3GYZ5YEH.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   sleep
@@ -28,18 +23,26 @@ import {
   fenceLock,
   getStateAdapter,
   withLock
-} from "./chunk-ORO3PWKQ.js";
+} from "./chunk-25SC7D6Z.js";
 import {
   botConfig,
+  completeText,
+  escapeXml,
+  resolveGatewayModel,
   unwrapCurrentInstruction
-} from "./chunk-7NVJVJID.js";
+} from "./chunk-32CXPIZE.js";
 import {
   toStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
+import {
+  parseSlackMessageTs
+} from "./chunk-F3B2YJ76.js";
 import {
   getActiveTraceId,
-  logException
-} from "./chunk-4LJO56OJ.js";
+  logException,
+  logWarn,
+  setSpanAttributes
+} from "./chunk-RLVZIWNQ.js";
 
 // src/chat/turn-context-tag.ts
 var TURN_CONTEXT_TAG = "runtime-turn-context";
@@ -178,10 +181,518 @@ function stripRuntimeTurnContext(messages) {
   });
 }
 
+// src/chat/services/context-budget.ts
+var COMPACTION_TRIGGER_RATIO = 0.9;
+var CONTEXT_INPUT_LIMIT_RATIO = 0.95;
+var COMPACTION_TARGET_RATIO = 0.8;
+var FALLBACK_CONTEXT_WINDOW_TOKENS = 4e5;
+function positiveInteger(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function estimateTextTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function calculateContextCompactionTriggerTokens(model) {
+  const contextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  return Math.max(1, Math.floor(contextWindow * COMPACTION_TRIGGER_RATIO));
+}
+function calculateContextInputLimitTokens(model) {
+  const contextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  return Math.max(1, Math.floor(contextWindow * CONTEXT_INPUT_LIMIT_RATIO));
+}
+function calculateContextCompactionTargetTokens(triggerTokens) {
+  return Math.max(1, Math.floor(triggerTokens * COMPACTION_TARGET_RATIO));
+}
+function getModelContextBudget(modelId) {
+  const model = resolveGatewayModel(modelId);
+  const advertisedContextWindow = positiveInteger(
+    model.contextWindow,
+    FALLBACK_CONTEXT_WINDOW_TOKENS
+  );
+  return {
+    contextWindow: Math.min(
+      botConfig.contextWindowTokens,
+      advertisedContextWindow
+    )
+  };
+}
+function getAgentContextCompactionTriggerTokens(modelId) {
+  return calculateContextCompactionTriggerTokens(
+    getModelContextBudget(modelId)
+  );
+}
+function getAgentContextInputLimitTokens(modelId) {
+  return calculateContextInputLimitTokens(getModelContextBudget(modelId));
+}
+function getConversationContextCompactionTriggerTokens() {
+  return calculateContextCompactionTriggerTokens(
+    getModelContextBudget(botConfig.fastModelId)
+  );
+}
+
+// src/chat/services/conversation-memory.ts
+var CONTEXT_MIN_LIVE_MESSAGES = 12;
+var CONTEXT_COMPACTION_BATCH_SIZE = 24;
+var CONTEXT_MAX_COMPACTIONS = 16;
+var CONTEXT_MAX_MESSAGE_CHARS = 3200;
+var SLACK_USER_ID_DISPLAY_PATTERN = /^[UW][A-Z0-9]{5,}$/;
+function generateConversationId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function normalizeConversationText(text) {
+  return text.replace(/\r\n?/g, "\n").trim();
+}
+function buildImageContextSuffix(message, conversation) {
+  const byFileId = conversation?.vision.byFileId;
+  const imageFileIds = message.meta?.imageFileIds ?? [];
+  if (!byFileId || imageFileIds.length === 0) {
+    return "";
+  }
+  const summaries = imageFileIds.map((fileId) => byFileId[fileId]?.summary?.trim()).filter((summary) => Boolean(summary));
+  if (summaries.length === 0) {
+    return "";
+  }
+  return ` [image context: ${summaries.join(" | ")}]`;
+}
+function renderConversationMessageLine(message, conversation) {
+  const displayName = conversationAuthorDisplayName(message);
+  const text = message.text.replace(/\s+/g, " ").slice(0, CONTEXT_MAX_MESSAGE_CHARS);
+  const markers = [];
+  if (message.meta?.replied === false) {
+    markers.push(
+      `assistant skipped: ${message.meta?.skippedReason ?? "no-reply route"}`
+    );
+  }
+  if (message.meta?.explicitMention) {
+    markers.push("explicit mention");
+  }
+  const markerSuffix = markers.length > 0 ? ` (${markers.join("; ")})` : "";
+  const imageContext = buildImageContextSuffix(message, conversation);
+  return `[${message.role}] ${displayName}: ${text}${imageContext}${markerSuffix}`;
+}
+function conversationAuthorDisplayName(message) {
+  const author = message.author;
+  const fullName = authorDisplayField(author?.fullName, author?.userId);
+  const userName = authorDisplayField(author?.userName, author?.userId);
+  return fullName ?? userName ?? (message.role === "assistant" ? botConfig.userName : message.role);
+}
+function authorDisplayField(value, userId) {
+  if (!value || value === userId || SLACK_USER_ID_DISPLAY_PATTERN.test(value)) {
+    return void 0;
+  }
+  return value;
+}
+function estimateConversationContextTokens(conversation) {
+  return estimateTextTokens(buildConversationContext(conversation) ?? "");
+}
+function upsertConversationMessage(conversation, message) {
+  const existingIndex = conversation.messages.findIndex(
+    (entry) => entry.id === message.id
+  );
+  if (existingIndex >= 0) {
+    conversation.messages[existingIndex] = {
+      ...conversation.messages[existingIndex],
+      ...message,
+      meta: {
+        ...conversation.messages[existingIndex]?.meta,
+        ...message.meta
+      }
+    };
+    return message.id;
+  }
+  conversation.messages.push(message);
+  return message.id;
+}
+function recordDeliveredAssistantMessage(args) {
+  const prefix = `${args.sessionId}:assistant:`;
+  const ordinal = args.conversation.messages.filter(
+    (message) => message.id.startsWith(prefix)
+  ).length + 1;
+  const messageId = `${prefix}${ordinal}`;
+  markConversationMessage(args.conversation, args.userMessageId, {
+    replied: true,
+    skippedReason: void 0
+  });
+  upsertConversationMessage(args.conversation, {
+    id: messageId,
+    role: "assistant",
+    text: normalizeConversationText(args.text),
+    createdAtMs: Date.now(),
+    author: {
+      userName: botConfig.userName,
+      isBot: true
+    },
+    meta: {
+      replied: true,
+      ...args.source ? { source: args.source } : {}
+    }
+  });
+  return messageId;
+}
+function turnHasReply(conversation, turnId) {
+  const assistantPrefix = `${turnId}:assistant:`;
+  return conversation.messages.some(
+    (message) => message.role === "assistant" && message.id.startsWith(assistantPrefix)
+  );
+}
+function markConversationMessage(conversation, messageId, patch) {
+  if (!messageId) return;
+  const messageIndex = conversation.messages.findIndex(
+    (entry) => entry.id === messageId
+  );
+  if (messageIndex < 0) return;
+  const current = conversation.messages[messageIndex];
+  conversation.messages[messageIndex] = {
+    ...current,
+    meta: {
+      ...current.meta ?? {},
+      ...patch
+    }
+  };
+}
+function buildConversationContext(conversation, options = {}) {
+  const messages = conversation.messages.filter(
+    (entry) => entry.id !== options.excludeMessageId
+  );
+  if (messages.length === 0 && conversation.compactions.length === 0) {
+    return void 0;
+  }
+  const lines = [];
+  if (conversation.compactions.length > 0) {
+    lines.push("<thread-compactions>");
+    for (const [index, compaction] of conversation.compactions.entries()) {
+      lines.push(
+        `  <compaction index="${index + 1}" covered_messages="${compaction.coveredMessageCount}" created_at="${new Date(compaction.createdAtMs).toISOString()}">`,
+        compaction.summary,
+        "  </compaction>"
+      );
+    }
+    lines.push("</thread-compactions>");
+  }
+  if (messages.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push("<thread-transcript>");
+    for (const [index, message] of messages.entries()) {
+      const author = escapeXml(conversationAuthorDisplayName(message));
+      const actorIdAttr = message.author?.userId ? ` actor_id="${escapeXml(message.author.userId)}"` : "";
+      const ts = new Date(message.createdAtMs).toISOString();
+      const slackTsAttr = message.meta?.slackTs ? ` slack_ts="${escapeXml(message.meta.slackTs)}"` : "";
+      lines.push(
+        `  <message index="${index + 1}" ts="${ts}" role="${message.role}" author="${author}"${actorIdAttr}${slackTsAttr}>`,
+        renderConversationMessageLine(message, conversation),
+        "  </message>"
+      );
+    }
+    lines.push("</thread-transcript>");
+  }
+  return lines.join("\n");
+}
+function pruneCompactions(compactions) {
+  if (compactions.length <= CONTEXT_MAX_COMPACTIONS) {
+    return compactions;
+  }
+  const overflowCount = compactions.length - CONTEXT_MAX_COMPACTIONS + 1;
+  const merged = compactions.slice(0, overflowCount);
+  const mergedSummary = merged.map((entry) => entry.summary).join("\n").slice(0, 3500);
+  const coveredMessageCount = merged.reduce(
+    (count, entry) => count + entry.coveredMessageCount,
+    0
+  );
+  const compacted = {
+    id: generateConversationId("compaction"),
+    createdAtMs: Date.now(),
+    summary: mergedSummary,
+    coveredMessageCount
+  };
+  return [compacted, ...compactions.slice(overflowCount)];
+}
+async function summarizeConversationChunk(messages, conversation, context, deps) {
+  const transcript = messages.map((message) => renderConversationMessageLine(message, conversation)).join("\n");
+  try {
+    const result = await deps.completeText({
+      modelId: botConfig.fastModelId,
+      temperature: 0,
+      promptName: "junior.thread_compaction",
+      messages: [
+        {
+          role: "user",
+          content: [
+            "Summarize the following older Slack thread transcript segment for future assistant turns.",
+            "Keep the summary factual and concise. Do not invent details.",
+            "",
+            "Output exactly three XML sections in this order:",
+            "<active-asks> one bullet per outstanding user ask that has not been narrowed, answered, or replaced by a later turn. Omit the section body if none. </active-asks>",
+            "<resolved-or-replaced-asks> one bullet per ask that has been replaced, narrowed, answered, or already acted on in this segment. Include the replacement/outcome inline. Omit the section body if none. </resolved-or-replaced-asks>",
+            "<facts> one bullet per durable fact useful regardless of scope: names, ids, URLs, decisions, locations, preferences, constraints that remain true. Omit the section body if none. </facts>",
+            "",
+            "Do not output any text outside the three sections.",
+            "",
+            transcript
+          ].join("\n"),
+          timestamp: Date.now()
+        }
+      ],
+      metadata: {
+        modelId: botConfig.fastModelId,
+        threadId: context.threadId ?? "",
+        channelId: context.channelId ?? "",
+        actorId: context.actorId ?? "",
+        runId: context.runId ?? ""
+      }
+    });
+    const summary = result.text.trim();
+    if (summary.length > 0) {
+      return summary.slice(0, 3500);
+    }
+  } catch (error) {
+    logWarn("conversation.compaction.summary.failed", {
+      "exception.message": error instanceof Error ? error.message : String(error),
+      "app.compaction_messages_covered": messages.length
+    });
+  }
+  return transcript.slice(0, 2800);
+}
+function getThreadTitleSourceMessage(conversation) {
+  let firstMessage;
+  for (const message of conversation.messages) {
+    if (!isHumanConversationMessage(message)) {
+      continue;
+    }
+    if (!firstMessage) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs < firstMessage.createdAtMs) {
+      firstMessage = message;
+      continue;
+    }
+    if (message.createdAtMs === firstMessage.createdAtMs && message.id < firstMessage.id) {
+      firstMessage = message;
+    }
+  }
+  return firstMessage;
+}
+async function compactConversationIfNeededWithDeps(conversation, context, deps) {
+  let estimatedTokens = estimateConversationContextTokens(conversation);
+  setSpanAttributes({
+    "app.context_tokens_estimated": estimatedTokens
+  });
+  const triggerTokens = getConversationContextCompactionTriggerTokens();
+  const targetTokens = calculateContextCompactionTargetTokens(triggerTokens);
+  while (estimatedTokens > triggerTokens && conversation.messages.length > CONTEXT_MIN_LIVE_MESSAGES) {
+    const compactCount = Math.min(
+      CONTEXT_COMPACTION_BATCH_SIZE,
+      conversation.messages.length - CONTEXT_MIN_LIVE_MESSAGES
+    );
+    if (compactCount <= 0) {
+      break;
+    }
+    const compactedChunk = conversation.messages.slice(0, compactCount);
+    const summary = await summarizeConversationChunk(
+      compactedChunk,
+      conversation,
+      context,
+      deps
+    );
+    conversation.compactions.push({
+      id: generateConversationId("compaction"),
+      createdAtMs: Date.now(),
+      summary,
+      coveredMessageCount: compactedChunk.length
+    });
+    conversation.compactions = pruneCompactions(conversation.compactions);
+    conversation.messages = conversation.messages.slice(compactCount);
+    estimatedTokens = estimateConversationContextTokens(conversation);
+    setSpanAttributes({
+      "app.compaction_messages_covered": compactCount,
+      "app.compaction.trigger_tokens": triggerTokens,
+      "app.compaction.target_tokens": targetTokens,
+      "app.context_tokens_estimated": estimatedTokens
+    });
+    if (estimatedTokens <= targetTokens) {
+      break;
+    }
+  }
+}
+function createConversationMemoryService(deps) {
+  return {
+    compactConversationIfNeeded: async (conversation, context) => await compactConversationIfNeededWithDeps(conversation, context, deps)
+  };
+}
+function isHumanConversationMessage(message) {
+  return message.role === "user" && message.author?.isBot !== true;
+}
+function getConversationMessageSlackTs(message) {
+  return parseSlackMessageTs(message.meta?.slackTs);
+}
+
 // src/chat/conversations/messages.ts
 import { createHash } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 
+// src/chat/services/short-title.ts
+var SHORT_TITLE_MAX_LENGTH = 60;
+var TITLE_PROMPTS = {
+  conversation: [
+    "Generate a concise 5-8 word conversation title from the first user message below.",
+    "Capture the user's main request.",
+    "Reply with ONLY the title, with no quotes or trailing punctuation."
+  ],
+  task: [
+    "Generate a concise 5-8 word task title from the task instruction below.",
+    "Capture the task's main purpose.",
+    "Reply with ONLY the title, with no quotes or trailing punctuation."
+  ]
+};
+function normalizeShortTitle(value) {
+  return value.replace(/\s+/g, " ").trim().slice(0, SHORT_TITLE_MAX_LENGTH);
+}
+function fallbackShortTitle(sourceText, fallback = "Untitled") {
+  const firstLine = sourceText.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? "";
+  return normalizeShortTitle(firstLine) || fallback;
+}
+async function generateShortTitle(args) {
+  const sourceText = args.sourceText.trim();
+  if (!sourceText) return void 0;
+  try {
+    const result = await args.completeText({
+      modelId: botConfig.fastModelId,
+      temperature: 0,
+      promptName: `junior.${args.kind}_title`,
+      messages: [
+        {
+          role: "user",
+          content: [
+            ...TITLE_PROMPTS[args.kind],
+            "",
+            args.kind === "conversation" ? `First user message: ${sourceText.slice(0, 500)}` : `Task instruction: ${sourceText.slice(0, 500)}`
+          ].join("\n"),
+          timestamp: Date.now()
+        }
+      ],
+      metadata: {
+        modelId: botConfig.fastModelId
+      }
+    });
+    const title = normalizeShortTitle(result.text);
+    return title || void 0;
+  } catch (error) {
+    logWarn(`${args.kind}.title.generation.failed`, {
+      "exception.message": error instanceof Error ? error.message : String(error)
+    });
+    return void 0;
+  }
+}
+async function resolveTaskTitle(args) {
+  const explicit = normalizeShortTitle(args.title ?? "");
+  if (explicit) return explicit;
+  return generateShortTitle({
+    completeText: args.completeText,
+    kind: "task",
+    sourceText: args.instruction
+  });
+}
+
+// src/chat/services/conversation-title.ts
+var inFlightTitles = /* @__PURE__ */ new Map();
+async function ensureConversationTitle(args) {
+  const pending = inFlightTitles.get(args.conversationId);
+  if (pending) {
+    return pending;
+  }
+  const work = ensureConversationTitleOnce(args).finally(() => {
+    inFlightTitles.delete(args.conversationId);
+  });
+  inFlightTitles.set(args.conversationId, work);
+  return work;
+}
+async function ensureConversationTitleOnce(args) {
+  if (!args.conversation.messages.some(isHumanConversationMessage)) {
+    return void 0;
+  }
+  const store = args.conversationStore ?? getConversationStore();
+  try {
+    const stored = await store.get({ conversationId: args.conversationId });
+    if (stored?.title?.trim()) {
+      return void 0;
+    }
+    if (stored?.lineage) {
+      return void 0;
+    }
+    const titleSourceMessage = getThreadTitleSourceMessage(args.conversation);
+    const sourceText = titleSourceMessage?.text.trim() ?? "";
+    if (!titleSourceMessage || !sourceText) {
+      return void 0;
+    }
+    let title;
+    try {
+      const generated = await generateShortTitle({
+        completeText,
+        kind: "conversation",
+        sourceText
+      });
+      title = generated ?? fallbackShortTitle(sourceText, "Conversation");
+    } catch (error) {
+      logWarn("conversation.title.generation.failed", {
+        "exception.message": error instanceof Error ? error.message : String(error)
+      });
+      title = fallbackShortTitle(sourceText, "Conversation");
+    }
+    const normalized = title.trim();
+    if (!normalized) {
+      return void 0;
+    }
+    const activityAtMs = titleSourceMessage.createdAtMs;
+    const nowMs = args.nowMs ?? Date.now();
+    try {
+      await store.recordActivity({
+        activityAtMs,
+        conversationId: args.conversationId,
+        nowMs,
+        title: normalized
+      });
+    } catch (error) {
+      logException(error, "conversation.title.persist.failed");
+      return void 0;
+    }
+    return normalized;
+  } catch (error) {
+    logException(error, "conversation.title.ensure.failed");
+    return void 0;
+  }
+}
+function scheduleConversationTitle(args) {
+  if (!args.conversationId) {
+    return;
+  }
+  void ensureConversationTitle({
+    conversation: args.conversation,
+    conversationId: args.conversationId
+  }).catch((error) => {
+    logException(error, "conversation.title.task.failed");
+  });
+}
+async function resolveConversationTitle(args) {
+  const pending = inFlightTitles.get(args.conversationId);
+  if (pending) {
+    const generated = await pending;
+    if (generated?.trim()) {
+      return generated.trim();
+    }
+  }
+  const store = args.conversationStore ?? getConversationStore();
+  const stored = await store.get({ conversationId: args.conversationId });
+  return stored?.title?.trim() || void 0;
+}
+
 // src/chat/conversations/message-summaries.ts
 import { isDeepStrictEqual } from "util";
 function projectConversationMessageSummaries(events) {
@@ -325,6 +836,10 @@ async function persistConversationMessages(args) {
     ...args,
     conversationId: args.conversationId
   });
+  scheduleConversationTitle({
+    conversation: args.conversation,
+    conversationId: args.conversationId
+  });
 }
 async function appendConversationMessages(eventStore, args) {
   if (args.conversation.messages.length === 0) return;
@@ -397,6 +912,131 @@ var piContentMessageSchema = z.object({
   role: z.string().min(1)
 }).passthrough().transform((value) => value);
 
+// src/chat/conversations/structured-events.ts
+import {
+  conversationEventPresentationSchema,
+  defineConversationEvent
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
+var JUNIOR_NATIVE_EVENT_NAMESPACE = "junior";
+var authenticationEventContentSchema = z2.object({
+  accountLabel: z2.string().trim().min(1).max(120).optional(),
+  actorId: z2.string().min(1),
+  authorizationId: z2.string().min(1).optional(),
+  provider: z2.string().regex(/^[a-z][a-z0-9-]*$/),
+  providerLabel: z2.string().trim().min(1).max(80).optional()
+}).strict();
+var agentsInstructionsUpdatedContentSchema = z2.object({
+  action: z2.enum(["loaded", "replaced", "cleared"]),
+  directory: z2.string().trim().min(1).max(500).optional(),
+  fingerprint: z2.string().trim().min(1).max(128),
+  sources: z2.array(
+    z2.object({
+      content: z2.string().min(1).max(32 * 1024),
+      path: z2.string().trim().min(1).max(500)
+    }).strict()
+  ).max(32),
+  textBytes: z2.number().int().nonnegative().optional()
+}).strict();
+function providerTitle(content) {
+  return content.providerLabel?.trim() || content.provider;
+}
+function agentsInstructionsTitle(action) {
+  if (action === "loaded") return "Loaded AGENTS.md";
+  if (action === "replaced") return "Updated AGENTS.md";
+  return "Cleared AGENTS.md";
+}
+function sourceFilename(sourcePath) {
+  return sourcePath.split("/").at(-1) || sourcePath;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} bytes`;
+  const kilobytes = bytes / 1024;
+  return `${Number.isInteger(kilobytes) ? kilobytes : kilobytes.toFixed(1)} KB`;
+}
+function agentsInstructionsPreview(content) {
+  const source = content.sources[0];
+  if (!source) return void 0;
+  const filename = sourceFilename(source.path);
+  const label = content.sources.length === 1 ? filename : `${content.sources.length} AGENTS.md files`;
+  return typeof content.textBytes === "number" ? `${label} \xB7 ${formatBytes(content.textBytes)}` : label;
+}
+var authenticationLinkedEvent = defineConversationEvent({
+  name: "authentication_linked",
+  version: 1,
+  schema: authenticationEventContentSchema,
+  renderEvent(event) {
+    const provider = providerTitle(event);
+    return {
+      icon: "link",
+      title: `${provider} connected`,
+      ...event.accountLabel ? { preview: `Connected as \`${event.accountLabel}\`` } : {},
+      details: [
+        {
+          title: `${provider} connected`,
+          ...event.accountLabel ? { description: `Connected as \`${event.accountLabel}\`` } : {},
+          metadata: [event.provider]
+        }
+      ]
+    };
+  }
+});
+var authenticationUnlinkedEvent = defineConversationEvent({
+  name: "authentication_unlinked",
+  version: 1,
+  schema: authenticationEventContentSchema,
+  renderEvent(event) {
+    const provider = providerTitle(event);
+    return {
+      icon: "key",
+      title: `${provider} disconnected`,
+      details: [
+        {
+          title: `${provider} disconnected`,
+          metadata: [event.provider]
+        }
+      ]
+    };
+  }
+});
+var agentsInstructionsUpdatedEvent = defineConversationEvent({
+  name: "agents_instructions_updated",
+  version: 1,
+  schema: agentsInstructionsUpdatedContentSchema,
+  renderEvent(event) {
+    const title = agentsInstructionsTitle(event.action);
+    const preview = agentsInstructionsPreview(event);
+    return {
+      icon: "brain",
+      title,
+      ...preview ? { preview } : {},
+      ...event.sources.length > 0 ? {
+        details: event.sources.map((source) => ({
+          title: sourceFilename(source.path),
+          content: source.content
+        }))
+      } : {}
+    };
+  }
+});
+var NATIVE_EVENT_DEFINITIONS = [
+  authenticationLinkedEvent,
+  authenticationUnlinkedEvent,
+  agentsInstructionsUpdatedEvent
+];
+function getJuniorNativeEventDefinition(args) {
+  return NATIVE_EVENT_DEFINITIONS.find(
+    (definition) => definition.eventName === args.name && definition.version === args.version
+  );
+}
+function renderJuniorNativeConversationEvent(args) {
+  if (args.namespace !== JUNIOR_NATIVE_EVENT_NAMESPACE) return void 0;
+  const definition = getJuniorNativeEventDefinition(args);
+  if (!definition) return void 0;
+  const presentation = definition.renderEvent(definition.parse(args.content));
+  return presentation === void 0 ? void 0 : conversationEventPresentationSchema.parse(presentation);
+}
+
 // src/chat/pi/conversation-events.ts
 function authorizationObservationMessage(data, createdAtMs) {
   const label = data.kind === "mcp" ? "MCP authorization" : "Authorization";
@@ -1131,7 +1771,7 @@ async function persistWithRetry(persist) {
 }
 
 // src/chat/task-execution/turn-cursor.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 
 // src/chat/repository-instructions.ts
 import { createHash as createHash2 } from "crypto";
@@ -1139,6 +1779,16 @@ import path2 from "path";
 
 // src/chat/tools/sandbox/file-utils.ts
 import path from "path";
+
+// src/chat/tools/execution/tool-input-error.ts
+var ToolInputError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ToolInputError";
+  }
+};
+
+// src/chat/tools/sandbox/file-utils.ts
 var MAX_TEXT_CHARS = 6e4;
 var RIPGREP_EXCLUDED_GLOBS = [
   "!**/.git/**",
@@ -1146,7 +1796,7 @@ var RIPGREP_EXCLUDED_GLOBS = [
 ];
 var DEFAULT_SEARCH_COMMAND_TIMEOUT_MS = 3e4;
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
-function positiveInteger(value) {
+function positiveInteger2(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     return void 0;
   }
@@ -1524,63 +2174,64 @@ function definedProps(values) {
     Object.entries(values).filter(([, value]) => value !== void 0)
   );
 }
-var turnStatusSchema = z2.enum([
+var turnStatusSchema = z3.enum([
   "running",
   "paused",
   "completed",
   "failed",
   "abandoned"
 ]);
-var turnSurfaceSchema = z2.enum([
+var turnSurfaceSchema = z3.enum([
   "slack",
   "api",
   "scheduler",
   "internal"
 ]);
-var turnPauseReasonSchema = z2.enum([
+var turnPauseReasonSchema = z3.enum([
   "timeout",
   "auth",
   "yield",
   "retry"
 ]);
-var nonNegativeNumberSchema = z2.number().finite().nonnegative();
-var seqCursorSchema = z2.number().int().min(-1);
-var storedTurnSummarySchema = z2.object({
-  schemaVersion: z2.literal(TURN_CURSOR_SCHEMA_VERSION),
-  version: z2.number().int().nonnegative(),
-  conversationId: z2.string().min(1),
-  dispatchId: z2.string().min(1).optional(),
-  dispatchOutcome: z2.enum(["blocked", "completed", "failed"]).optional(),
-  resultMessageId: z2.string().min(1).optional(),
+var nonNegativeNumberSchema = z3.number().finite().nonnegative();
+var seqCursorSchema = z3.number().int().min(-1);
+var storedTurnSummarySchema = z3.object({
+  schemaVersion: z3.literal(TURN_CURSOR_SCHEMA_VERSION),
+  version: z3.number().int().nonnegative(),
+  conversationId: z3.string().min(1),
+  dispatchId: z3.string().min(1).optional(),
+  dispatchOutcome: z3.enum(["blocked", "completed", "failed"]).optional(),
+  resultMessageId: z3.string().min(1).optional(),
   resumeReason: turnPauseReasonSchema.optional(),
-  turnId: z2.string().min(1),
-  sliceId: z2.number().int().nonnegative(),
+  turnId: z3.string().min(1),
+  sliceId: z3.number().int().nonnegative(),
   state: turnStatusSchema,
   surface: turnSurfaceSchema.optional(),
   updatedAtMs: nonNegativeNumberSchema
 }).strip();
-var storedTurnRecordSchema = z2.object({
-  schemaVersion: z2.literal(TURN_CURSOR_SCHEMA_VERSION),
-  version: z2.number().int().nonnegative(),
-  conversationId: z2.string().min(1),
-  dispatchId: z2.string().min(1).optional(),
-  dispatchOutcome: z2.enum(["blocked", "completed", "failed"]).optional(),
-  resultMessageId: z2.string().min(1).optional(),
+var storedTurnRecordSchema = z3.object({
+  schemaVersion: z3.literal(TURN_CURSOR_SCHEMA_VERSION),
+  version: z3.number().int().nonnegative(),
+  conversationId: z3.string().min(1),
+  dispatchId: z3.string().min(1).optional(),
+  dispatchOutcome: z3.enum(["blocked", "completed", "failed"]).optional(),
+  resultMessageId: z3.string().min(1).optional(),
   lastProgressAtMs: nonNegativeNumberSchema,
   resumeReason: turnPauseReasonSchema.optional(),
-  resumedFromSliceId: z2.number().int().nonnegative().optional(),
-  turnId: z2.string().min(1),
-  sliceId: z2.number().int().nonnegative(),
+  publishExternally: z3.boolean().optional(),
+  resumedFromSliceId: z3.number().int().nonnegative().optional(),
+  turnId: z3.string().min(1),
+  sliceId: z3.number().int().nonnegative(),
   startedAtMs: nonNegativeNumberSchema,
   state: turnStatusSchema,
   surface: turnSurfaceSchema.optional(),
-  traceId: z2.string().optional(),
+  traceId: z3.string().optional(),
   updatedAtMs: nonNegativeNumberSchema,
   committedSeq: seqCursorSchema,
-  historyVersion: z2.number().int().nonnegative().optional(),
-  errorMessage: z2.string().optional(),
+  historyVersion: z3.number().int().nonnegative().optional(),
+  errorMessage: z3.string().optional(),
   turnStartSeq: seqCursorSchema.optional(),
-  runtimeContext: z2.array(piMessageSchema).optional()
+  runtimeContext: z3.array(piMessageSchema).optional()
 }).strip();
 function conversationExecutionFromSummary(summary) {
   const status = summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state;
@@ -1629,7 +2280,7 @@ async function recordConversationActivityMetadata(args) {
   });
   const isChild = Boolean(conversation?.lineage);
   const destination = isChild ? void 0 : args.destination;
-  const activitySource = isChild ? "internal" : destination?.platform === "local" ? "local" : destination ? args.summary.surface : void 0;
+  const activitySource = isChild ? "internal" : args.source?.platform === "web" ? "web" : destination?.platform === "local" ? "local" : destination ? args.summary.surface : void 0;
   await conversationStore.recordActivity({
     activityAtMs: args.summary.updatedAtMs,
     channelName: args.summary.channelName,
@@ -1681,6 +2332,7 @@ function materializeTurnRecord(stored, piProjection, turnStartMessageIndex, rest
       dispatchOutcome: stored.dispatchOutcome,
       errorMessage: stored.errorMessage,
       resumeReason: stored.resumeReason,
+      publishExternally: stored.publishExternally,
       resultMessageId: stored.resultMessageId,
       resumedFromSliceId: stored.resumedFromSliceId,
       surface: stored.surface,
@@ -1790,6 +2442,7 @@ function buildStoredRecord(args) {
       errorMessage: args.errorMessage,
       historyVersion: args.historyVersion,
       resumeReason: args.resumeReason,
+      publishExternally: args.publishExternally,
       resultMessageId: args.resultMessageId,
       resumedFromSliceId: args.resumedFromSliceId,
       runtimeContext: args.runtimeContext && args.runtimeContext.length > 0 ? args.runtimeContext : void 0,
@@ -1877,6 +2530,7 @@ async function updateTurnState(args) {
         errorMessage: args.errorMessage ?? args.existing.errorMessage,
         historyVersion: parsed.historyVersion,
         resumeReason: args.existing.resumeReason,
+        publishExternally: args.existing.publishExternally,
         resultMessageId: args.resultMessageId ?? args.existing.resultMessageId,
         resumedFromSliceId: args.existing.resumedFromSliceId,
         surface: args.existing.surface,
@@ -1964,6 +2618,7 @@ async function upsertTurnRecordLocked(args, fence) {
         errorMessage: args.errorMessage,
         lastProgressAtMs: args.lastProgressAtMs,
         resumeReason: args.resumeReason,
+        publishExternally: args.publishExternally ?? existingRecord?.publishExternally,
         resultMessageId: args.resultMessageId ?? existingRecord?.resultMessageId,
         resumedFromSliceId: args.resumedFromSliceId,
         runtimeContext: args.state === "running" || args.state === "paused" ? retainedRuntimeContext : void 0,
@@ -2120,6 +2775,96 @@ async function failTurnRecord(args) {
   );
 }
 
+// src/chat/usage.ts
+var agentTurnUsageSchema = usageSchema;
+var COMPONENT_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cachedInputTokens",
+  "cacheCreationTokens"
+];
+var COST_COMPONENT_FIELDS = [
+  "input",
+  "output",
+  "cacheRead",
+  "cacheWrite"
+];
+function hasAgentTurnUsage(usage) {
+  return Boolean(
+    usage && (Object.entries(usage).some(
+      ([field, value]) => field !== "cost" && typeof value === "number" && Number.isFinite(value)
+    ) || Object.values(usage.cost ?? {}).some(
+      (value) => typeof value === "number" && Number.isFinite(value)
+    ))
+  );
+}
+function getFiniteCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function getFiniteCost(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+}
+function addCost(left, right) {
+  return Math.round(((left ?? 0) + right) * 1e12) / 1e12;
+}
+function getComponentTotal(usage) {
+  let total;
+  for (const field of COMPONENT_USAGE_FIELDS) {
+    const value = getFiniteCount(usage[field]);
+    if (value === void 0) continue;
+    total = (total ?? 0) + value;
+  }
+  return total;
+}
+function addAgentTurnUsage(...usages) {
+  const components = {};
+  let componentTotal;
+  let totalOnlyTokens;
+  let reasoningTokens;
+  const cost = {};
+  for (const usage of usages) {
+    if (!usage) continue;
+    const reasoning = getFiniteCount(usage.reasoningTokens);
+    if (reasoning !== void 0) {
+      reasoningTokens = (reasoningTokens ?? 0) + reasoning;
+    }
+    if (usage.cost) {
+      for (const field of [...COST_COMPONENT_FIELDS, "total"]) {
+        const value = getFiniteCost(usage.cost[field]);
+        if (value === void 0) continue;
+        cost[field] = addCost(cost[field], value);
+      }
+    }
+    const usageComponentTotal = getComponentTotal(usage);
+    if (usageComponentTotal !== void 0) {
+      componentTotal = (componentTotal ?? 0) + usageComponentTotal;
+      for (const field of COMPONENT_USAGE_FIELDS) {
+        const value = getFiniteCount(usage[field]);
+        if (value === void 0) continue;
+        components[field] = (components[field] ?? 0) + value;
+      }
+      continue;
+    }
+    const totalTokens = getFiniteCount(usage.totalTokens);
+    if (totalTokens !== void 0) {
+      totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
+    }
+  }
+  if (totalOnlyTokens !== void 0) {
+    return {
+      totalTokens: totalOnlyTokens + (componentTotal ?? 0),
+      ...reasoningTokens !== void 0 ? { reasoningTokens } : {},
+      ...Object.keys(cost).length > 0 ? { cost } : {}
+    };
+  }
+  const result = {
+    ...components,
+    ...reasoningTokens !== void 0 ? { reasoningTokens } : {},
+    ...Object.keys(cost).length > 0 ? { cost } : {}
+  };
+  return hasAgentTurnUsage(result) ? result : void 0;
+}
+
 // src/chat/services/turn-limit.ts
 var TurnSliceLimitExceededError = class extends Error {
   constructor(maxSlices) {
@@ -2180,6 +2925,7 @@ function sharedWrite(args, latest) {
       destination: args.destination,
       destinationVisibility: args.destinationVisibility,
       dispatchId: args.dispatchId ?? latest?.dispatchId,
+      publishExternally: args.publishExternally ?? latest?.publishExternally,
       source: args.source,
       surface: args.surface ?? latest?.surface,
       traceId: getActiveTraceId() ?? latest?.traceId,
@@ -2371,6 +3117,7 @@ function isPendingAuthLatestRequest(conversation, pendingAuth) {
 }
 
 export {
+  renderJuniorNativeConversationEvent,
   TURN_CONTEXT_TAG,
   isAssistantMessage,
   isToolResultMessage,
@@ -2388,6 +3135,24 @@ export {
   stripRuntimeTurnContext,
   historyItemFromPiMessage,
   piMessageFromHistoryItem,
+  estimateTextTokens,
+  getAgentContextCompactionTriggerTokens,
+  getAgentContextInputLimitTokens,
+  normalizeConversationText,
+  estimateConversationContextTokens,
+  upsertConversationMessage,
+  recordDeliveredAssistantMessage,
+  turnHasReply,
+  markConversationMessage,
+  buildConversationContext,
+  createConversationMemoryService,
+  isHumanConversationMessage,
+  getConversationMessageSlackTs,
+  SHORT_TITLE_MAX_LENGTH,
+  fallbackShortTitle,
+  generateShortTitle,
+  resolveTaskTitle,
+  resolveConversationTitle,
   persistConversationMessageSummaries,
   hydrateConversationMessages,
   persistConversationMessages,
@@ -2407,10 +3172,11 @@ export {
   recordTurnRoute,
   recordToolExecutionStarted,
   recordGuardianActionReviewed,
+  ToolInputError,
   MAX_TEXT_CHARS,
   RIPGREP_EXCLUDED_GLOBS,
   DEFAULT_SEARCH_COMMAND_TIMEOUT_MS,
-  positiveInteger,
+  positiveInteger2 as positiveInteger,
   normalizeToLf,
   truncateText,
   isMissingPathError,
@@ -2445,6 +3211,9 @@ export {
   sanitizeAssistantText,
   decideReply,
   getAssistantReplyText,
+  agentTurnUsageSchema,
+  hasAgentTurnUsage,
+  addAgentTurnUsage,
   TurnSliceLimitExceededError,
   buildTurnLimitResponse,
   persistWithRetry,