@buzzni/saycode-cli 0.9.9 → 0.9.10

package/README.md

@@ -211,10 +211,20 @@ saycode를 따로 설치하지 않은 작업PC는 `npx @buzzni/saycode-cli searc
 마무리합니다(specs/codexcli-approval-session-binding R12). 값이 없거나 모르는 값이면 아무것도 싣지 않고,
 자식은 지금처럼 사람의 답을 기다립니다.
 
+`agent prompt`의 결과는 `resultVersion:2`입니다. `ok:true`는 서버 저장 행을 다시 조회·복호화하여 본문과 설정까지 확인했다는 뜻이며 `storage.seq`가 확인한 위치입니다. `delivered:true`는 그 서버 메시지 ID의 **런타임 소비 증거**가 있어야 나옵니다. 구버전의 `delivered`는 같은 뜻으로 읽으면 안 됩니다. 큐 수락(receipt)만으로는 소비나 답변 성공이 아닙니다.
+
+`--wait` 없이도 저장 뒤 runtime의 수락·거부 receipt를 최대 5초 기다려 거부를 바로 알려 주며, receipt가 없으면 `outcome:unconfirmed`로 돌아옵니다. `--wait`는 저장 이후 같은 입력 ID의 증인으로 기다립니다(최대 600초, 저장·검사 포함 620초). `response.attribution=bound`일 때만 `response.answer`가 이번 질문의 단독 답변이며, 공동 배치·steer·질문/자유문 권한 답변이 끼면 `consumed-with`와 입력 목록/사유를 돌려줍니다. receipt timeout은 `outcome:unconfirmed`이고 실패로 확정하지 않습니다. 소비는 확인됐지만 마감까지 작업이 끝나지 않으면 같은 증거를 담은 `wait_timeout`(exit 3)이고, 소비된 턴이 `--until` 조건 없이 끝나면(예: `consumed-with`) 마감을 기다리지 않고 `outcome:unconfirmed`로 바로 돌려줍니다. `next.command` 또는 `happy agent read <id> --since <storage.seq>`로 늦은 receipt·소비를 정산하세요.
+
+재실행에 대비하려면 **송신 전** `--local-id <id>`와 대상·본문·설정을 보관합니다(1–128 ASCII 영숫자 및 `._:-`). 같은 ID/동일 intent로 저장 응답 유실을 한 번만 재시도하며, 다른 본문이나 설정이면 `localid_conflict`입니다. CLI가 죽은 뒤에는 보관한 같은 ID로 다시 실행해 원래 저장 행을 확인합니다. 그사이 대상 runtime이 재시작되면 확인 조건이 달라져 `localid_conflict`가 되지만, 본문이 같으면(`storage.existing.sameBody:true`) `storage.existing`과 `next.command`(`happy agent read <id> --since <seq>`)로 원래 요청의 소비 여부를 확인할 수 있습니다. 본문이 다르면 그 행은 다른 질문이므로 `next.command`를 주지 않습니다. ID를 보관하지 않은 송신은 본문·시각으로 찾지 않으므로 결과를 알 수 없습니다. 복호화/조회 실패는 `storage-verification-unknown`입니다. 미확인 요청을 새 ID로 자동 재전송하지 않습니다.
+
+입력 증거는 지원 Claude/Codex 세션의 명시적 opt-in(`HAPPY_INPUT_EVIDENCE=1`, 기본 OFF)과 살아 있는 동일 runtime/remote epoch 확인이 필요합니다. 그 확인이 안 되는 세션(ON marker 없는 .358, 미지원·OFF 세션)은 `CLI_GUARDED_PROMPT_ROLLOUT`(기본 off) 동안 이전처럼 보내되 결과는 `resultVersion:2`, `delivered:false`, `delivery.state:"unsupported"`로 소비를 주장하지 않습니다. 이 플래그를 켜면 같은 세션은 `prompt_unsupported`로 보내기 전에 닫힙니다. Desktop 자동 opt-in은 T2r pin 전까지 꺼져 있습니다. A6 생성 안내는 T4rt와 함께 수락합니다. 허브 자동 알림은 `HUB_BRIDGE_OWNERSHIP_ROLLOUT`(기본 off) 동안 이전과 같고, 켜면 main이 개인은 같은 계정, 회사는 confirmed owner만 수신하도록 확인하며 확인 실패 시 배지에서 복구를 안내합니다. 사람의 직접 입력은 유지됩니다.
+
 `steer` 성공의 `accepted:true`는 세션 RPC가 요청을 받았다는 뜻이며 실제 transcript 전달 완료를
 뜻하지 않습니다(`delivered:false`). 끝난 턴의 후속 작업에는 `prompt`를 사용합니다. 에이전트 세션은
 자기 자신에게 입력할 수 없고, `steer`와 `stop`은 depth와 관계없이 원장에 기록된 자기 후손에게만 보낼 수
-있습니다. 후손이 아닌 세션에 `prompt`하려면 소유가 검증돼야 하며, `not_owned`를 받으면 `read`로만 보고
+있습니다. 예외로 사람이 시작한 Claude·Codex 허브(broker 경로, depth 0)는 소유가 검증된 형제 세션(`ls`의
+`ownership.relation:"own-sibling"`)에도 보낼 수 있으며, 이때 `stop`은 프로세스를 끄지 않고 지금 응답만 끊습니다
+(`mode:"turn-abort"`, 터미널에서 쓰는 Claude는 stop을 `controlled-by-user`, steer를 `local-mode`로 거부). 형제 결과에는 대상 `title`과 `ownership.relation`이 붙습니다. 형제에게 보내기 전에 대상 제목과 전체 ID를 확인합니다. 후손이 아닌 세션에 `prompt`하려면 소유가 검증돼야 하며, `not_owned`를 받으면 `read`로만 보고
 다시 시도하지 않습니다(ADR-078). `stop`은 보관·삭제를 하지 않습니다. spawn 한도(`whoami`의 `maxSpawn`)는 세션이
 도는 머신의 코어·메모리에서 산정하므로 머신마다 다르고, 최근 6시간 안의 spawn만 세는 롤링 윈도우라
 소진돼도 시간이 지나면 회복됩니다(`budgetResetsAt`, ADR-063). 데몬이 확인하지 못한 시도도 같은
@@ -510,3 +520,9 @@ node ../../scripts/verify-cli-tarball.mjs out/cli/buzzni-saycode-cli-*.tgz
 
 번들에 포함된 서드파티 오픈소스는 각자의 라이선스를 유지하며, 목록과 전문은 패키지에
 동봉된 `THIRD-PARTY-NOTICES.md`에 있습니다 (빌드 시 실제 번들 내용에서 자동 생성).
+
+T2 응답은 소비한 native turn과 runtime에 결속합니다. `prompt --wait`의 질문·구조화 출력도 그 턴만 판정하며 `structuredOutput`과 `structured_output_missing`을 v2에 유지합니다. 명시적 runtime 거부는 `prompt_rejected`, exit 3이며 localId·storage·거부 증거를 보존합니다. 백그라운드 후속 관측은 `response.followUps`에 따로 남기고 최초 답변을 덮지 않습니다.
+
+송신 당시 검증된 runtime/epoch는 암호화 요청에 보존하므로 host 재시작 뒤에도 `read --since`로 과거 소비 사실을 조회할 수 있습니다. 이 기록은 새 runtime에 송신 권한을 주지 않습니다. 검증 기록이 없는 구 요청은 현재 runtime이 같고 ON이어도 unknown으로 남습니다. 기록을 소급 생성하거나 과거 소비를 확인됐다고 표시하지 않습니다.
+
+Codex 명령/패치 승인은 tool 시작 전에 대기할 수 있지만 .359의 REST pending 상태에는 approval↔turn 결속이 없습니다. `prompt --wait --until waiting-input`은 이 승인을 현재 턴으로 추측하지 않습니다. 해당 대기가 확인되지 않은 채 timeout되면 `outcome:unconfirmed`, `waitingInput:{state:"unsupported",reason:"pending-approval-turn-binding-unavailable"}`를 반환합니다. 이는 pending 승인이 요청 B에 속한다는 뜻이 아닙니다. Claude 질문·Codex 질문은 실제 tool-call ID/턴 결속이 있을 때 판정하며, 채널 routing requestId로 대체하지 않습니다. 미확인 결과를 새 메시지로 자동 재시도하지 마세요.

package/channel-extension-host.mjs

@@ -7,7 +7,7 @@ const ASSET_PERMISSIONS = ["assets.read", "assets.write", "files.select", "draft
 function usesAssetWorkflow(permissions) {
   return permissions.some((permission) => ASSET_PERMISSIONS.includes(permission));
 }
-const LONG_RUNNING_PERMISSIONS = ["localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "machine.run"];
+const LONG_RUNNING_PERMISSIONS = ["localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "browser.runtimeSetup", "machine.run"];
 function extensionRequestTimeoutMs(permissions, side) {
   const long = usesAssetWorkflow(permissions) || permissions.some((permission) => LONG_RUNNING_PERMISSIONS.includes(permission));
   if (!long) return void 0;
@@ -469,8 +469,11 @@ function parseExtensionArtifactActions(value, path2 = "manifest.contributes.arti
     };
   });
 }
-const CHANNEL_API_VERSION = 1;
+const CHANNEL_API_VERSION = 2;
 const CHANNEL_MINIMUM_API_VERSION = 1;
+function isSupportedChannelApiVersion(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= CHANNEL_MINIMUM_API_VERSION && value <= CHANNEL_API_VERSION;
+}
 const CHANNEL_PROVIDERS = ["telegram", "slack", "discord"];
 const CHANNEL_COMMAND_SCHEMA = Object.freeze({
   pair: Object.freeze(["code!"]),
@@ -611,6 +614,7 @@ const EXTENSION_PERMISSIONS = [
   "localTools.install",
   "localTools.control",
   "localBrowser.setup",
+  "browser.runtimeSetup",
   "network.fetch",
   "notifications.show",
   "storage.read",
@@ -633,7 +637,11 @@ const EXTENSION_PERMISSIONS = [
   "channels.transport",
   "sessions.read",
   "sessions.control",
-  "sessions.approveOnce"
+  "sessions.approveOnce",
+  // Core → adapter, not a capability the adapter invokes: Core sends the current input and the
+  // thread's earlier messages (other people's words included) for display-text normalization
+  // (specs/slack-bot-improvements contracts §2). Channel API 2 only.
+  "channels.normalize"
 ];
 const CONVERSATION_MODS_INTERNAL = typeof __SAYCODE_MODS_INTERNAL__ !== "undefined" && __SAYCODE_MODS_INTERNAL__ === true;
 const SAYCODE_EXTENSION_API_VERSION = CONVERSATION_MODS_INTERNAL ? 5 : 4;
@@ -644,7 +652,7 @@ const SAYCODE_CHANNEL_API_VERSION = CHANNEL_API_VERSION;
 const SAYCODE_CHANNEL_MINIMUM_API_VERSION = CHANNEL_MINIMUM_API_VERSION;
 class UnsupportedChannelApiVersionError extends Error {
   constructor(channelApiVersion) {
-    super(`manifest.channelApiVersion: channel API version ${String(channelApiVersion)} is unsupported; Desktop supports ${String(SAYCODE_CHANNEL_API_VERSION)}`);
+    super(`manifest.channelApiVersion: channel API version ${String(channelApiVersion)} is unsupported; Desktop supports ${`${SAYCODE_CHANNEL_MINIMUM_API_VERSION}-${SAYCODE_CHANNEL_API_VERSION}`}`);
     this.channelApiVersion = channelApiVersion;
   }
   name = "UnsupportedChannelApiVersionError";
@@ -667,7 +675,7 @@ const V2_PERMISSIONS = /* @__PURE__ */ new Set([
   "browserViewer.install",
   "browserViewer.installChrome"
 ]);
-const V3_PERMISSIONS = /* @__PURE__ */ new Set(["machine.run", "artifacts.publishPublic", "assets.read", "assets.write", "files.select", "drafts.prepare", "localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup"]);
+const V3_PERMISSIONS = /* @__PURE__ */ new Set(["machine.run", "artifacts.publishPublic", "assets.read", "assets.write", "files.select", "drafts.prepare", "localTools.inspect", "localTools.install", "localTools.control", "localBrowser.setup", "browser.runtimeSetup"]);
 const CHANNEL_PERMISSIONS = /* @__PURE__ */ new Set([
   "channels.receive",
   "channels.ack",
@@ -675,7 +683,8 @@ const CHANNEL_PERMISSIONS = /* @__PURE__ */ new Set([
   "channels.transport",
   "sessions.read",
   "sessions.control",
-  "sessions.approveOnce"
+  "sessions.approveOnce",
+  "channels.normalize"
 ]);
 const TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "id",
@@ -925,6 +934,9 @@ function parseExtensionManifest(value, options) {
       if (channelApiVersion === void 0) {
         fail$5(`manifest.permissions[${index}]`, "requires manifest.channelApiVersion");
       }
+      if (typed === "channels.normalize" && channelApiVersion < 2) {
+        fail$5(`manifest.permissions[${index}]`, "channels.normalize requires channel API version 2");
+      }
     }
     return typed;
   });
@@ -1073,6 +1085,246 @@ function parseChannelApprovalRequest(value) {
   }
   return { approvalHandle, approveLabel, denyLabel };
 }
+const NORMALIZE_ADDITION_SOURCES = ["blocks", "quote", "forward", "table", "unfurl", "files"];
+const MAX_NORMALIZE_ITEMS = 200;
+const MAX_USER_LABELS = 200;
+const MAX_BLOCKS = 50;
+const MAX_ATTACHMENTS = 20;
+const MAX_FILES = 20;
+const MAX_RICH_TEXT_DEPTH = 6;
+const MAX_URL_LENGTH = 2048;
+const MAX_ADDITIONS_BYTES = 8192;
+const MAX_PRIMARY_BYTES = 65536;
+const ITEM_REF = /^i(0|[1-9]\d?|1\d\d)$/;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isString = (value) => typeof value === "string";
+function projectSlackMessage(raw) {
+  const state = { truncated: false };
+  const message = isRecord(raw) ? raw : {};
+  const projection = {};
+  const blocks = projectBlocks(message.blocks, state);
+  if (blocks) projection.blocks = blocks;
+  const attachments = capped(Array.isArray(message.attachments) ? message.attachments.filter(isRecord) : [], MAX_ATTACHMENTS, state).map((attachment) => projectAttachment(attachment, state));
+  if (attachments.length > 0) projection.attachments = attachments;
+  const files = capped(Array.isArray(message.files) ? message.files.filter(isRecord) : [], MAX_FILES, state).map(projectFile);
+  if (files.length > 0) projection.files = files;
+  if (isString(message.subtype)) projection.subtype = message.subtype;
+  return { projection, truncated: state.truncated };
+}
+function capped(items, max, state) {
+  if (items.length > max) state.truncated = true;
+  return items.slice(0, max);
+}
+function projectBlocks(value, state) {
+  if (!Array.isArray(value)) return void 0;
+  const projected = value.map((block) => projectBlock(block, state)).filter((block) => block !== null);
+  return projected.length > 0 ? capped(projected, MAX_BLOCKS, state) : void 0;
+}
+function projectBlock(block, state) {
+  if (!isRecord(block)) return null;
+  switch (block.type) {
+    case "rich_text":
+      return { type: "rich_text", elements: projectContainers(block.elements, 1, state) };
+    case "section": {
+      const section = { type: "section" };
+      const text2 = projectTextObject(block.text);
+      if (text2) section.text = text2;
+      if (Array.isArray(block.fields)) section.fields = block.fields.map(projectTextObject).filter((field) => field !== null);
+      return section;
+    }
+    case "header": {
+      const text2 = projectTextObject(block.text);
+      return text2 ? { type: "header", text: text2 } : null;
+    }
+    case "context":
+      return { type: "context", elements: Array.isArray(block.elements) ? block.elements.map(projectTextObject).filter((element) => element !== null) : [] };
+    case "table":
+      return { type: "table", rows: Array.isArray(block.rows) ? block.rows.filter(Array.isArray).map((row2) => row2.flatMap((cell) => {
+        if (isRecord(cell) && cell.type === "raw_text" && isString(cell.text)) return [{ type: "raw_text", text: cell.text }];
+        if (isRecord(cell) && cell.type === "rich_text") return [{ type: "rich_text", elements: projectContainers(cell.elements, 1, state) }];
+        return [];
+      })) : [] };
+    default:
+      return null;
+  }
+}
+function projectTextObject(value) {
+  if (!isRecord(value) || value.type !== "mrkdwn" && value.type !== "plain_text" || !isString(value.text)) return null;
+  return { type: value.type, text: value.text };
+}
+const CONTAINER_TYPES = /* @__PURE__ */ new Set(["rich_text_section", "rich_text_quote", "rich_text_preformatted", "rich_text_list"]);
+function projectContainers(value, depth, state) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((node) => {
+    const container = isRecord(node) && CONTAINER_TYPES.has(String(node.type)) ? projectContainer(node, depth, state) : null;
+    return container ? [container] : [];
+  });
+}
+function projectContainer(node, depth, state) {
+  if (depth > MAX_RICH_TEXT_DEPTH) {
+    state.truncated = true;
+    return null;
+  }
+  const elements = (Array.isArray(node.elements) ? node.elements : []).flatMap((child) => {
+    if (isRecord(child) && CONTAINER_TYPES.has(String(child.type))) {
+      const nested = projectContainer(child, depth + 1, state);
+      return nested ? [nested] : [];
+    }
+    const leaf = projectLeaf(child);
+    return leaf ? [leaf] : [];
+  });
+  const container = { type: node.type, elements };
+  if (node.style === "bullet" || node.style === "ordered") container.style = node.style;
+  return container;
+}
+function projectLeaf(node) {
+  if (!isRecord(node)) return null;
+  switch (node.type) {
+    case "text": {
+      if (!isString(node.text)) return null;
+      const leaf = { type: "text", text: node.text };
+      if (isRecord(node.style)) {
+        const style = Object.fromEntries(["bold", "italic", "strike", "code"].filter((key) => typeof node.style[key] === "boolean").map((key) => [key, node.style[key]]));
+        if (Object.keys(style).length > 0) leaf.style = style;
+      }
+      return leaf;
+    }
+    case "link": {
+      const label = isString(node.text) ? node.text : void 0;
+      if (!httpUrl(node.url)) return label === void 0 ? null : { type: "text", text: label };
+      return label === void 0 ? { type: "link", url: node.url } : { type: "link", url: node.url, text: label };
+    }
+    case "user":
+      return isString(node.user_id) ? { type: "user", user_id: node.user_id } : null;
+    case "channel":
+      return isString(node.channel_id) ? { type: "channel", channel_id: node.channel_id } : null;
+    case "usergroup":
+      return isString(node.usergroup_id) ? { type: "usergroup", usergroup_id: node.usergroup_id } : null;
+    case "emoji":
+      return isString(node.name) ? { type: "emoji", name: node.name } : null;
+    case "broadcast":
+      return node.range === "here" || node.range === "channel" || node.range === "everyone" ? { type: "broadcast", range: node.range } : null;
+    default:
+      return null;
+  }
+}
+const ATTACHMENT_TEXT_KEYS = ["text", "fallback", "pretext", "title", "author_name", "footer"];
+const ATTACHMENT_URL_KEYS = ["title_link", "from_url", "original_url"];
+function projectAttachment(attachment, state) {
+  const projected = {};
+  for (const key of ATTACHMENT_TEXT_KEYS) if (isString(attachment[key])) projected[key] = attachment[key];
+  for (const key of ATTACHMENT_URL_KEYS) if (httpUrl(attachment[key])) projected[key] = attachment[key];
+  if (typeof attachment.is_share === "boolean") projected.is_share = attachment.is_share;
+  if (typeof attachment.is_msg_unfurl === "boolean") projected.is_msg_unfurl = attachment.is_msg_unfurl;
+  if (Array.isArray(attachment.message_blocks)) {
+    projected.message_blocks = attachment.message_blocks.filter(isRecord).map((forwarded) => ({
+      message: { blocks: projectBlocks(isRecord(forwarded.message) ? forwarded.message.blocks : void 0, state) ?? [] }
+    }));
+  }
+  return projected;
+}
+function projectFile(file) {
+  const projected = {};
+  for (const key of ["name", "title", "filetype", "mimetype"]) if (isString(file[key])) projected[key] = file[key];
+  if (Number.isSafeInteger(file.size) && file.size >= 0) projected.size = file.size;
+  return projected;
+}
+function httpUrl(value) {
+  return isString(value) && value.length <= MAX_URL_LENGTH && /^https?:\/\//i.test(value);
+}
+function parseChannelNormalizeRequest(value) {
+  const request = plainRecord(value, "normalize request");
+  exactKeySet(request, ["apiVersion", "channelId", "connectionId", "provider", "connectionRevision", "requestId", "purpose", "userLabels", "items"], "normalize request");
+  if (request.apiVersion !== 2 || request.provider !== "slack") fail("normalize request is channel API 2 Slack only");
+  if (request.purpose !== "currentInput" && request.purpose !== "threadHistory") fail("invalid normalize purpose");
+  if (!Number.isSafeInteger(request.connectionRevision) || request.connectionRevision < 1) fail("invalid normalize connection revision");
+  const labels = plainRecord(request.userLabels, "normalize userLabels");
+  if (Object.keys(labels).length > MAX_USER_LABELS || Object.entries(labels).some(([key, label]) => key.length === 0 || key.length > 64 || !isString(label) || label.length > 256)) {
+    fail("invalid normalize userLabels");
+  }
+  if (!Array.isArray(request.items) || request.items.length < 1 || request.items.length > MAX_NORMALIZE_ITEMS) fail("invalid normalize items");
+  const refs = /* @__PURE__ */ new Set();
+  const items = request.items.map((value2) => {
+    const item = plainRecord(value2, "normalize item");
+    exactKeySet(item, ["itemRef", "primaryText", "projection", "maxAdditionsBytes"], "normalize item");
+    if (!isString(item.itemRef) || !ITEM_REF.test(item.itemRef) || refs.has(item.itemRef)) fail("invalid normalize itemRef");
+    refs.add(item.itemRef);
+    if (!isString(item.primaryText) || utf8Bytes(item.primaryText) > MAX_PRIMARY_BYTES) fail("invalid normalize primaryText");
+    if (!Number.isSafeInteger(item.maxAdditionsBytes) || item.maxAdditionsBytes < 1 || item.maxAdditionsBytes > MAX_ADDITIONS_BYTES) fail("invalid normalize maxAdditionsBytes");
+    const projected = projectSlackMessage(item.projection);
+    if (!isRecord(item.projection) || projected.truncated || !sameJson(projected.projection, item.projection)) fail("normalize projection is not a Core projection");
+    return { itemRef: item.itemRef, primaryText: item.primaryText, projection: projected.projection, maxAdditionsBytes: item.maxAdditionsBytes };
+  });
+  return {
+    apiVersion: 2,
+    provider: "slack",
+    purpose: request.purpose,
+    channelId: boundedText(request.channelId, "channelId"),
+    connectionId: boundedText(request.connectionId, "connectionId"),
+    connectionRevision: request.connectionRevision,
+    requestId: boundedText(request.requestId, "requestId"),
+    userLabels: { ...labels },
+    items
+  };
+}
+function parseChannelNormalizeResult(request, value) {
+  const result = plainRecord(value, "normalize result");
+  exactKeySet(result, ["items"], "normalize result");
+  if (!Array.isArray(result.items)) fail("invalid normalize result items");
+  const wanted = new Map(request.items.map((item) => [item.itemRef, item]));
+  const parsed = /* @__PURE__ */ new Map();
+  for (const value2 of result.items) {
+    const item = plainRecord(value2, "normalize result item");
+    exactKeySet(item, ["itemRef", "additions", "truncated"], "normalize result item");
+    const requested = isString(item.itemRef) ? wanted.get(item.itemRef) : void 0;
+    if (!requested || parsed.has(requested.itemRef)) fail("normalize result items differ from the request");
+    if (typeof item.truncated !== "boolean" || !Array.isArray(item.additions)) fail("invalid normalize result item");
+    let bytes = 0;
+    const additions = item.additions.map((value3) => {
+      const addition = plainRecord(value3, "normalize addition");
+      exactKeySet(addition, ["source", "text"], "normalize addition");
+      if (!NORMALIZE_ADDITION_SOURCES.includes(addition.source) || !isString(addition.text) || addition.text.includes("\0") || hasLoneSurrogate(addition.text)) fail("invalid normalize addition");
+      bytes += utf8Bytes(addition.text);
+      return { source: addition.source, text: addition.text };
+    });
+    if (bytes > requested.maxAdditionsBytes) fail("normalize additions exceed their budget");
+    parsed.set(requested.itemRef, { itemRef: requested.itemRef, additions: withoutRepeatedLines(requested.primaryText, additions), truncated: item.truncated });
+  }
+  if (parsed.size !== wanted.size) fail("normalize result items differ from the request");
+  return request.items.map((item) => parsed.get(item.itemRef));
+}
+function withoutRepeatedLines(primaryText, additions) {
+  const fold = (line) => line.replace(/\s+/gu, " ").trim();
+  const known = new Set(primaryText.split("\n").map(fold).filter(Boolean));
+  const kept = [];
+  for (const addition of additions) {
+    const lines2 = addition.text.split("\n");
+    const remaining = lines2.filter((line) => fold(line) === "" || !known.has(fold(line)));
+    for (const line of lines2) if (fold(line)) known.add(fold(line));
+    if (remaining.some((line) => fold(line) !== "")) kept.push({ source: addition.source, text: remaining.join("\n") });
+  }
+  return kept;
+}
+function exactKeySet(record2, keys2, path2) {
+  const actual = Object.keys(record2);
+  if (actual.length !== keys2.length || !keys2.every((key) => actual.includes(key))) fail(`${path2} has unexpected keys`);
+}
+function boundedText(value, path2) {
+  if (!isString(value) || value.length === 0 || value.length > 200) fail(`invalid normalize ${path2}`);
+  return value;
+}
+function sameJson(a, b) {
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, index) => sameJson(item, b[index]));
+  }
+  if (isRecord(a) && isRecord(b)) {
+    const keys2 = Object.keys(a);
+    return keys2.length === Object.keys(b).length && keys2.every((key) => Object.hasOwn(b, key) && sameJson(a[key], b[key]));
+  }
+  return Object.is(a, b);
+}
+const utf8Bytes = (text2) => new TextEncoder().encode(text2).length;
+const hasLoneSurrogate = (text2) => /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(text2);
 function finiteNumber(value, path2) {
   if (typeof value !== "number" || !Number.isFinite(value)) fail(`${path2} must be a finite number`);
   return value;
@@ -1162,13 +1414,15 @@ function parseRequest(message) {
         "maxChunkUtf16Units",
         "maxChunks"
       ];
+      const v2 = params.apiVersion === 2;
       exactKeys(
         params,
-        "approval" in params ? [...formatKeys, "approval"] : formatKeys,
+        v2 ? [...formatKeys, "mode", "dialect"] : "approval" in params ? [...formatKeys, "approval"] : formatKeys,
         "request.params"
       );
+      if (v2 && (params.mode !== "verbatim" && params.mode !== "rendered" || params.dialect !== "slack-mrkdwn" || params.kind === "approval")) fail("invalid channel API 2 formatter request");
       const lifecycle = parseRequest({ kind: "request", id: id2, method: "channel.lifecycle", params: {
-        apiVersion: params.apiVersion,
+        apiVersion: v2 ? 1 : params.apiVersion,
         channelId: params.channelId,
         connectionId: params.connectionId,
         provider: params.provider,
@@ -1184,16 +1438,26 @@ function parseRequest(message) {
       }
       const approval = params.approval === void 0 ? void 0 : parseChannelApprovalRequest(params.approval);
       const { state: _state, ...identity } = lifecycle.params;
+      const bounds = { requestId, text: body, maxChunks: Number(params.maxChunks), maxChunkUtf16Units: Number(params.maxChunkUtf16Units) };
+      if (v2) {
+        return { kind: "request", id: id2, method, params: {
+          ...identity,
+          ...bounds,
+          apiVersion: 2,
+          kind: params.kind,
+          mode: params.mode,
+          dialect: "slack-mrkdwn"
+        } };
+      }
       return { kind: "request", id: id2, method, params: {
         ...identity,
-        requestId,
-        text: body,
+        ...bounds,
         kind: params.kind,
-        maxChunks: Number(params.maxChunks),
-        maxChunkUtf16Units: Number(params.maxChunkUtf16Units),
         ...approval ? { approval } : {}
       } };
     }
+    case "channel.normalizeMessages":
+      return { kind: "request", id: id2, method, params: parseChannelNormalizeRequest(params) };
     case "invokeCommand": {
       exactKeys(params, ["commandId", "args"], "request.params");
       if (!Array.isArray(params.args)) fail("request.params.args must be an array");
@@ -1276,6 +1540,17 @@ function parseExtensionWireMessage(value) {
   if (message.kind === "event") return parseEvent(message);
   fail("message.kind is unknown");
 }
+function parseChannelRenderedReplyResult(value) {
+  const result = plainRecord(value, "channel rendered result");
+  if (Object.keys(result).join() !== "rendered" || !Array.isArray(result.rendered)) fail("invalid channel rendered result");
+  return {
+    rendered: result.rendered.map((value2) => {
+      const chunk = plainRecord(value2, "channel rendered chunk");
+      if (Object.keys(chunk).sort().join() !== "sourceEnd,sourceStart,text" || typeof chunk.text !== "string" || !Number.isSafeInteger(chunk.sourceStart) || !Number.isSafeInteger(chunk.sourceEnd)) fail("invalid channel rendered chunk");
+      return { text: chunk.text, sourceStart: chunk.sourceStart, sourceEnd: chunk.sourceEnd };
+    })
+  };
+}
 const TIMEOUT = Symbol("extension-request-timeout");
 function requestEnvelope(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
@@ -1297,6 +1572,7 @@ class ExtensionHostRuntime {
   widgets = /* @__PURE__ */ new Map();
   channelHandlers = /* @__PURE__ */ new Map();
   channelFormatters = /* @__PURE__ */ new Map();
+  channelNormalizers = /* @__PURE__ */ new Map();
   channelIntakeHandlers = /* @__PURE__ */ new Map();
   channelStates = /* @__PURE__ */ new Map();
   channelCalls = /* @__PURE__ */ new Map();
@@ -1432,6 +1708,7 @@ class ExtensionHostRuntime {
       this.commandHandlers.clear();
       this.channelHandlers.clear();
       this.channelFormatters.clear();
+      this.channelNormalizers.clear();
       this.channelIntakeHandlers.clear();
       this.channelStates.clear();
       this.channelCalls.clear();
@@ -1475,6 +1752,7 @@ class ExtensionHostRuntime {
         this.commandHandlers.clear();
         this.channelHandlers.clear();
         this.channelFormatters.clear();
+        this.channelNormalizers.clear();
         this.channelIntakeHandlers.clear();
         this.channelStates.clear();
         this.channelCalls.clear();
@@ -1495,6 +1773,7 @@ class ExtensionHostRuntime {
     }
     if (request.method === "channel.lifecycle") return this.deliverChannel(request.params);
     if (request.method === "channel.formatReply") return this.formatChannelReply(request.params);
+    if (request.method === "channel.normalizeMessages") return this.normalizeChannelMessages(request.params);
     if (request.method === "channel.intake") return this.deliverChannelIntake(request.params);
     const handler = this.commandHandlers.get(request.params.commandId);
     if (!handler) {
@@ -1507,7 +1786,7 @@ class ExtensionHostRuntime {
   }
   async deliverChannel(event) {
     const contribution = this.options.manifest.contributes.channels?.find((channel) => channel.id === event.channelId);
-    if (this.options.manifest.channelApiVersion !== 1 || !contribution || contribution.provider !== event.provider) {
+    if (!isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !contribution || contribution.provider !== event.provider) {
       throw { code: "CHANNEL_NOT_DECLARED", message: "channel contribution/provider is not declared" };
     }
     const key = JSON.stringify([event.channelId, event.connectionId]);
@@ -1553,16 +1832,29 @@ class ExtensionHostRuntime {
     return null;
   }
   async formatChannelReply(input) {
-    const key = JSON.stringify([input.channelId, input.connectionId]);
-    const current = this.channelStates.get(key);
-    const epoch = this.channelEpoch;
+    const isCurrent = this.channelCallIsCurrent(input);
     const formatter = this.channelFormatters.get(input.channelId);
-    const isCurrent = () => !this.disposed && !this.deactivating && this.active && epoch === this.channelEpoch && this.channelStates.get(key) === current && current?.state === "start" && current.provider === input.provider && current.connectionRevision === input.connectionRevision;
     if (!isCurrent() || !formatter) throw { code: "CHANNEL_FORMAT_UNAVAILABLE", message: "channel formatter is not active" };
     const result = await formatter(Object.freeze({ ...input }));
     if (!isCurrent()) throw { code: "CHANNEL_FORMAT_WITHDRAWN", message: "channel formatter stopped" };
+    if (input.apiVersion === 2 && input.mode === "rendered") return parseChannelRenderedReplyResult(result);
     return parseChannelReplyFormatResult(result, input);
   }
+  async normalizeChannelMessages(input) {
+    const isCurrent = this.channelCallIsCurrent(input);
+    const normalizer = this.channelNormalizers.get(input.channelId);
+    if (!isCurrent() || !normalizer) throw { code: "CHANNEL_NORMALIZE_UNAVAILABLE", message: "channel normalizer is not active" };
+    const result = await normalizer(Object.freeze({ ...input }));
+    if (!isCurrent()) throw { code: "CHANNEL_NORMALIZE_WITHDRAWN", message: "channel normalizer stopped" };
+    return { items: parseChannelNormalizeResult(input, result) };
+  }
+  /** A formatter or normalizer answers only for the started connection generation it was asked about. */
+  channelCallIsCurrent(input) {
+    const key = JSON.stringify([input.channelId, input.connectionId]);
+    const current = this.channelStates.get(key);
+    const epoch = this.channelEpoch;
+    return () => !this.disposed && !this.deactivating && this.active && epoch === this.channelEpoch && this.channelStates.get(key) === current && current?.state === "start" && current.provider === input.provider && current.connectionRevision === input.connectionRevision;
+  }
   async withTimeout(operation) {
     let timer;
     const timeout = new Promise((resolve2) => {
@@ -1596,6 +1888,7 @@ class ExtensionHostRuntime {
       const registered = /* @__PURE__ */ new Map();
       const registeredChannels = /* @__PURE__ */ new Map();
       const registeredFormatters = /* @__PURE__ */ new Map();
+      const registeredNormalizers = /* @__PURE__ */ new Map();
       const registeredIntake = /* @__PURE__ */ new Map();
       await loaded.activate({
         extensionId: this.options.manifest.id,
@@ -1605,19 +1898,26 @@ class ExtensionHostRuntime {
         } },
         channels: {
           register: (channelId, handler) => {
-            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredChannels.has(channelId)) {
+            if (!this.activating || !isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredChannels.has(channelId)) {
               throw { code: "INVALID_CHANNEL_REGISTRATION", message: "channel must be declared and registered once" };
             }
             registeredChannels.set(channelId, handler);
           },
           registerFormatter: (channelId, formatter) => {
-            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof formatter !== "function" || registeredFormatters.has(channelId)) {
+            if (!this.activating || !isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof formatter !== "function" || registeredFormatters.has(channelId)) {
               throw { code: "INVALID_CHANNEL_REGISTRATION", message: "formatter must be declared and registered once" };
             }
             registeredFormatters.set(channelId, formatter);
           },
+          registerNormalizer: (channelId, normalizer) => {
+            const manifest = this.options.manifest;
+            if (!this.activating || (manifest.channelApiVersion ?? 0) < 2 || !manifest.permissions.includes("channels.normalize") || !manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof normalizer !== "function" || registeredNormalizers.has(channelId)) {
+              throw { code: "INVALID_CHANNEL_REGISTRATION", message: "normalizer needs channel API 2, channels.normalize and one registration" };
+            }
+            registeredNormalizers.set(channelId, normalizer);
+          },
           onIntake: (channelId, handler) => {
-            if (!this.activating || this.options.manifest.channelApiVersion !== 1 || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredIntake.has(channelId)) {
+            if (!this.activating || !isSupportedChannelApiVersion(this.options.manifest.channelApiVersion) || !this.options.manifest.contributes.channels?.some((channel) => channel.id === channelId) || typeof handler !== "function" || registeredIntake.has(channelId)) {
               throw { code: "INVALID_CHANNEL_REGISTRATION", message: "intake handler must be declared and registered once" };
             }
             registeredIntake.set(channelId, handler);
@@ -1639,7 +1939,9 @@ class ExtensionHostRuntime {
       for (const [id2, render] of registeredWidgets) this.widgets.set(id2, render);
       this.channelHandlers.clear();
       this.channelFormatters.clear();
+      this.channelNormalizers.clear();
       for (const [id2, formatter] of registeredFormatters) this.channelFormatters.set(id2, formatter);
+      for (const [id2, normalizer] of registeredNormalizers) this.channelNormalizers.set(id2, normalizer);
       this.channelIntakeHandlers.clear();
       for (const [id2, handler] of registeredIntake) this.channelIntakeHandlers.set(id2, handler);
       for (const [id2, handler] of registeredChannels) this.channelHandlers.set(id2, handler);