@buzzni/saycode-cli 0.9.7 → 0.9.9

package/README.md

@@ -136,8 +136,9 @@ Happy CLI 설치본은 동일한 agent 명령을 `happy agent` facade로 제공
 먼저 `happy agent whoami`로 capability와 spawn 한도를 확인해야 합니다.
 
 ```bash
-happy agent ls --status         # 스코프 안 세션의 상태·대기 사유·마지막 응답·seq 커서
+happy agent ls --status         # 스코프 안 세션의 상태·작업 맥락·연락 방식(statusVersion:2)
 happy agent spawn --prompt "변경사항을 읽기 전용으로 리뷰해줘"
+happy agent spawn --prompt "위험도를 판정해줘" --output-schema '{"type":"object","properties":{"risk":{"enum":["low","high"]}},"required":["risk"]}'
 happy agent prompt <id> "리뷰 근거를 더 설명해줘"
 happy agent wait --any <id1> <id2> --until turn-end   # 여럿 중 하나라도 끝나면 반환
 happy agent read <id> --since <seq>                   # 마지막으로 읽은 뒤의 변경분만
@@ -147,6 +148,40 @@ happy agent steer <id> <text>   # 지금 생성 중인 응답의 방향만 수
 happy agent stop <id>           # 사용자가 명시한 경우에만 현재 응답 중단
 ```
 
+`ls --status` v2는 전체 `id`, 제목(80자)·요약(240자), 사람 표시 정보(`verified:false`), 머신,
+저장소·브랜치, `runtime`, 최근 작업 `activity`, `observedAt`·`activityObservedAt`·`stale`,
+`ownership`, `contact.prompt/steer/stop`의 상태·사유·실행 영향을 보여 줍니다. 사람 정보는
+`createdBy`의 주장일 뿐 소유 증명이 아닙니다. 저장소 정본 정보는 없어 `repository:null`, 브랜치는
+`metadata.worktree.branch`만 쓰며 빈 값과 ID 제목은 null입니다. 동명 대화도 전체 ID로 선택하세요.
+최근 50개 원본 메시지의 Claude TodoWrite·Codex plan에서 진행 중 작업 3개만 읽습니다. 빈/완료 목록은
+none, 창 밖·ACP plan 미저장은 사유가 있는 unknown입니다. 재개 뒤 이전 조회의 작업을 되살리지 않습니다.
+Claude의 `activity.source:TodoWrite`와 sourceMessageId/sourceSeq는 호출 시작 시 입력 목록의 출처이며
+쓰기 성공을 증명하지 않습니다. 현재 happy-cli mapper가 개별 tool_result의 `is_error`를 보내지 않아,
+TodoWrite가 실패했어도 오류 정보 없는 tool-call-end 뒤 턴이 completed이면 관측한 목록을 유지합니다.
+개별 실패 탐지는 알려진 검증 한계입니다. 향후 같은 call ID의 `is_error:true`가 실제로 오면 unknown으로
+내립니다. 실패/취소된 턴은 별도로 unknown 처리하며, 무관한 call이나 subagent 오류를 결속하지 않습니다.
+조회 실패는 상태도 unknown이며 오류 원문을 노출하지 않습니다. 최신순 최대 100행·UTF-8 768KiB,
+동시 조회 4개이며 초과하면 `truncated:true`, `candidateCount`는 읽기 허용 후보 수만 셉니다.
+
+`contact`는 T1b 실제 verb 게이트의 거부(`reason`·`authorizationReason`)를 그대로 반영하고 그 뒤에
+대상 runtime 능력과 실행 상태를 표시합니다. 조회 가능과 변경 가능은 다릅니다. `available`도 실행 보장이
+아니며 실제 명령에서 재검사합니다. 120초보다 오래된 `stale:true` 또는 시간 미확인의 `stale:unknown`은
+연락 전에 다시 확인하세요. no-wake는 미지원, Claude local은 switch-required(자동 전환 없음),
+능력 미광고인 기존 pin은 unknown입니다. P1 실앱 수락은 Claude 비 mandatory·Codex account broker 허브이며
+Gemini·opencode·grok 직접 허브는 P1 실앱 수락 범위 밖입니다(실제 권한 표시는 유지, steer 미지원).
+mandatory Claude는 `not_agent_env`라 행을 만들지 않습니다. 기본 `ls` 출력 계약은 그대로입니다.
+
+`spawn --output-schema`는 inline JSON 또는 절대 경로의 JSON Schema(draft-07, 모르는 키워드·`$async` 불가 — 번들 Claude CLI와 같은 규칙)를 받아, 그 자식(Claude만)의 **세션 전체**
+— 이후 `agent prompt`로 보낸 턴까지 — 를 그 schema로 답하게 합니다. 한 세션에 query 하나를 유지하는 런타임 구조라
+턴마다 schema를 바꿀 수 없기 때문입니다. `wait`/`prompt --wait`는 그 턴의 검증된 값을 `structuredOutput`으로 돌려주고,
+턴이 끝났는데 값이 없으면(`subtype: success`여도) `structured_output_missing`으로 실패합니다. `read`는 실패 없이
+`structuredOutput.status`를 보여 주고, `wait --any`는 만족된 세션마다 판정을 `structuredOutput[<id>]`에 담을 뿐
+대기 전체를 실패시키지 않습니다. 취소된 턴도 `missing`(`turn_cancelled`)으로 끝나며, `/compact` 턴과 일시적 API
+오류로 자동 재시도되기 전의 실패 턴도 각각 `missing`으로 보입니다. 머신 런타임이 `structuredOutput` capability를
+광고하지 않으면 `structured_output_unsupported`로 거절하고 세션을 만들지 않습니다(구버전 daemon은 필드를 조용히
+버리기 때문). 구조화 세션의 마지막 답은 schema JSON이라 `<saycode-complete>` 완료 신호가 나오지 않으므로
+`--until completed` 대신 `--until turn-end`로 기다리세요. 일반 세션의 완료 신호 계약은 바뀌지 않습니다.
+
 `read --around`는 표시 창만 옮깁니다 — `completion`·`lastSeq`는 여전히 최신 창 기준이라 `--since` 커서와 함께 쓸 수
 있고, 둘을 한 호출에 같이 주지는 못합니다. 없는 seq는 오류가 아니라 `around.found:false`와 가장 가까운 메시지로 답합니다.
 `read`는 계정 최신 150개 목록에서 밀려난 세션도 **정확한 id**로 엽니다(같은 스코프 판정, 이름·접두 매칭 없음).
@@ -169,10 +204,18 @@ saycode를 따로 설치하지 않은 작업PC는 `npx @buzzni/saycode-cli searc
 `--worktree`로 만든 자식만 자기 worktree를 `root`로 갖고, `scope`는 그대로 부모의 것을 물려받습니다
 (ADR-065) — 그래야 부모가 계속 그 자식을 보고 제어할 수 있습니다.
 
+부모 세션의 런타임이 지금 턴의 분류(`SAYCODE_DELEGATED_ATTENDANCE`: `unattended`·`attended`)를 넘겨 주면
+`spawn`(대화를 넘기는 `spawn --handoff` 포함)은 그 값을 자식 env에, `prompt`는 자기가 spawn한 자손에게 보내는 메시지 meta(`delegatedAttendance`)에만
+싣습니다(사람의 대화 등 그 밖의 세션에는 싣지 않아 그 대화는 계속 사람의 답을 기다립니다). 예약 작업처럼
+지켜보는 사람이 없는 턴이 띄운 자식이나 넘겨받은 새 대화는 승인을 영원히 기다리지 않고 런타임의 무인 대기 시간 뒤 거절로
+마무리합니다(specs/codexcli-approval-session-binding R12). 값이 없거나 모르는 값이면 아무것도 싣지 않고,
+자식은 지금처럼 사람의 답을 기다립니다.
+
 `steer` 성공의 `accepted:true`는 세션 RPC가 요청을 받았다는 뜻이며 실제 transcript 전달 완료를
-뜻하지 않습니다(`delivered:false`). 끝난 턴의 후속 작업에는 `prompt`를 사용합니다. 사람이 시작한 세션
-(`depth` 0)은 스코프 안 모든 세션에 `steer`와 `stop`을 보낼 수 있고, spawn된 세션은 원장에 기록된 최대
-2단계 자식만 허용하며, `stop`은 보관·삭제를 하지 않습니다. spawn 한도(`whoami`의 `maxSpawn`)는 세션이
+뜻하지 않습니다(`delivered:false`). 끝난 턴의 후속 작업에는 `prompt`를 사용합니다. 에이전트 세션은
+자기 자신에게 입력할 수 없고, `steer`와 `stop`은 depth와 관계없이 원장에 기록된 자기 후손에게만 보낼 수
+있습니다. 후손이 아닌 세션에 `prompt`하려면 소유가 검증돼야 하며, `not_owned`를 받으면 `read`로만 보고
+다시 시도하지 않습니다(ADR-078). `stop`은 보관·삭제를 하지 않습니다. spawn 한도(`whoami`의 `maxSpawn`)는 세션이
 도는 머신의 코어·메모리에서 산정하므로 머신마다 다르고, 최근 6시간 안의 spawn만 세는 롤링 윈도우라
 소진돼도 시간이 지나면 회복됩니다(`budgetResetsAt`, ADR-063). 데몬이 확인하지 못한 시도도 같은
 6시간을 차감합니다 — 응답만 유실됐을 뿐 세션은 만들어졌을 수 있기 때문입니다. 깊이 상한에는 이런
@@ -188,6 +231,12 @@ worktree는 계정 로그인이 있어야 만들 수 있고, 부모에 커밋되
 ref는 부모 HEAD로 폴백하지 않고 거절합니다. 결과 JSON의 `worktreeId`·`branch`·
 `baseSha`로 나중에 결과를 회수하며, 합류(merge·PR)는 자동으로 하지 않습니다.
 
+격리된 세션의 broker 경로도 관리형 worktree 생성을 지원합니다. Git 상태는 격리된 CLI에서 읽고,
+worktree 생성도 같은 격리 client가 수행합니다. 인증을 가진 host는 현재 프로젝트·머신을 확인하고
+기존 관리형 등록 API로 결과를 검증한 뒤 자식을 시작합니다. CLI client와 내장
+host에 모두 이 지원이 필요합니다. 오래된 조합에서 Git snapshot이 없으면 업데이트 안내와 함께
+거절하며, 같은 폴더 생성으로 자동 전환하지 않습니다.
+
 ## 긴 prompt 작성과 재사용
 
 TTY의 유휴 chat prompt에서 `/edit-prompt`를 입력하면 외부 편집기가 열립니다. 편집기는 `$VISUAL`,
@@ -309,7 +358,8 @@ emoji의 표시 폭도 반영합니다. 링크는 파이프 출력에서도 목
 GUI 없는 머신(Debian/Ubuntu, macOS — Windows는 `run`만)에서 Saycode 서버와 중계를 직접 운영합니다. 소유자 1명용이며,
 서버 머신 자신도 작업 머신이 됩니다. 휴대폰·Desktop·이 CLI와 다른 작업 머신이 이 서버에 붙습니다.
 
-**준비물**: Node 20 이상. Linux는 `sudo apt install openssl python3 make g++`가 필요합니다. openssl이 없으면 서버가 시작
+**준비물**: Node 20 이상. Node 20이면 npm 11 이상도 필요합니다(`npm install -g npm@11`) — Node 20에서는 npm 10(함께 설치되는 10.8.2와
+10.9.9 확인)이 `init`의 서버 패키지 설치 중 `Cannot read properties of null (reading 'edgesOut')`로 실패합니다. Node 22.22 이상은 기본 npm(10.9)으로 됩니다. Linux는 `sudo apt install openssl python3 make g++`가 필요합니다. openssl이 없으면 서버가 시작
 직후 멈춥니다. 빌드 도구는 아키텍처와 관계없이(x64·arm64) `happy-cli`의 `node-pty`를 소스에서 빌드하는 데 씁니다. 서버 머신도
 자기 daemon을 위해 `happy-cli`를 설치하므로 함께 필요합니다. 에이전트를 쓰려면 각 머신에서 Claude Code·Codex 로그인이 필요합니다.
 

package/channel-extension-host.mjs

@@ -48,6 +48,93 @@ function contributionList(value, path2, allowedKeys, parse) {
     return parse(entry, entryPath);
   });
 }
+const ENTRYPOINT_PATTERN = /\.(?:cjs|mjs|js)$/;
+function relativePath(value, path2, requireScript = false) {
+  const parsed = string(value, path2);
+  const segments = parsed.split("/");
+  if (parsed.startsWith("/") || parsed.includes("\\") || segments.some((segment) => segment === "" || segment === "." || segment === "..") || requireScript && !ENTRYPOINT_PATTERN.test(parsed)) {
+    fail$5(path2, "expected safe relative path");
+  }
+  return parsed;
+}
+function keys$1(value, allowed) {
+  const result = record$1(value, "widget");
+  assertOnlyKeys(result, new Set(allowed), "widget");
+  if (allowed.some((key) => !Object.hasOwn(result, key))) fail$5("widget", "missing field");
+  return result;
+}
+function text$3(value, limit = 4096) {
+  if (typeof value !== "string" || new TextEncoder().encode(value).length > limit) fail$5("widget", "invalid text");
+  return value;
+}
+function number(value, max = Number.MAX_SAFE_INTEGER) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > max) fail$5("widget", "invalid number");
+  return value;
+}
+function bounded(value) {
+  const encoded = JSON.stringify(value);
+  if (!encoded || new TextEncoder().encode(encoded).length > 32768) fail$5("widget", "payload exceeds 32 KiB");
+}
+function parseChatWidgets(value, apiVersion) {
+  if (apiVersion !== 5) fail$5("manifest.contributes.chatWidgets", "requires Extension API version 5");
+  const result = contributionList(value, "manifest.contributes.chatWidgets", ["id", "title", "order"], (entry) => ({
+    id: id(entry.id, "widget.id"),
+    title: text$3(entry.title, 256),
+    order: number(entry.order ?? 0, 1e3)
+  }));
+  if (result.length > 2) fail$5("manifest.contributes.chatWidgets", "at most two widgets");
+  return result;
+}
+function parseWidgetTree(value) {
+  let count = 0;
+  const walk = (input, depth) => {
+    if (++count > 100 || depth > 8) fail$5("widget", "tree limit exceeded");
+    const node = record$1(input, "widget");
+    if (node.type === "text") {
+      keys$1(node, ["type", "text"]);
+      return { type: "text", text: text$3(node.text) };
+    }
+    if (node.type === "metric") {
+      keys$1(node, ["type", "label", "value", "tone"]);
+      if (node.tone !== "neutral" && node.tone !== "warning") fail$5("widget", "invalid tone");
+      return { type: "metric", label: text$3(node.label), value: text$3(node.value), tone: node.tone };
+    }
+    keys$1(node, ["type", "children"]);
+    if (node.type !== "list" || !Array.isArray(node.children)) fail$5("widget", "invalid node");
+    return { type: "list", children: node.children.map((child) => walk(child, depth + 1)) };
+  };
+  const result = walk(value, 1);
+  bounded(result);
+  return result;
+}
+function parseWidgetSnapshot(value) {
+  const row2 = keys$1(value, ["version", "language", "provider", "model", "running", "context", "quota", "goal"]);
+  if (row2.version !== 1 || typeof row2.running !== "boolean") fail$5("widget", "invalid snapshot");
+  const context = row2.context === null ? null : keys$1(row2.context, ["usedTokens", "limitTokens", "observedAt"]);
+  const quota = keys$1(row2.quota, ["state", "reason", "observedAt", "windows"]);
+  const states = ["fresh", "partial", "stale", "unavailable", "unsupported", "scope-missing", "probe-disabled", "backing-off"];
+  if (!states.includes(String(quota.state)) || !Array.isArray(quota.windows) || quota.windows.length > 2) fail$5("widget", "invalid quota");
+  if (!["fresh", "partial"].includes(String(quota.state)) && quota.windows.length) fail$5("widget", "unavailable quota has numbers");
+  const windows = quota.windows.map((value2) => {
+    const window = keys$1(value2, ["kind", "usedPercent", "resetsAt"]);
+    if (window.kind !== "fiveHour" && window.kind !== "sevenDay") fail$5("widget", "invalid window");
+    return { kind: window.kind, usedPercent: number(window.usedPercent, 100), resetsAt: window.resetsAt === null ? null : number(window.resetsAt) };
+  });
+  if (new Set(windows.map((window) => window.kind)).size !== windows.length) fail$5("widget", "duplicate window");
+  const goal = row2.goal === null ? null : keys$1(row2.goal, ["status", "text"]);
+  const result = {
+    version: 1,
+    language: text$3(row2.language, 8),
+    provider: text$3(row2.provider, 64),
+    model: row2.model === null ? null : text$3(row2.model, 128),
+    running: row2.running,
+    context: context ? { usedTokens: number(context.usedTokens), limitTokens: number(context.limitTokens), observedAt: context.observedAt === null ? null : number(context.observedAt) } : null,
+    quota: { state: String(quota.state), reason: quota.reason === null ? null : text$3(quota.reason, 256), observedAt: quota.observedAt === null ? null : number(quota.observedAt), windows },
+    goal: goal ? { status: text$3(goal.status, 64), text: text$3(goal.text) } : null
+  };
+  bounded(result);
+  return result;
+}
 function parseExtensionFileViewers(value, apiVersion) {
   if (apiVersion < 4) fail$5("manifest.contributes.fileViewers", "requires Extension API version 4");
   return contributionList(value, "manifest.contributes.fileViewers", ["id", "title", "extensions", "panelId"], (entry, path2) => {
@@ -60,6 +147,23 @@ function assertExtensionFileViewers(extensionId2, viewers, panels, permissions)
     if (!permissions.includes("filePreviews.read") || !viewer.id.startsWith(`${extensionId2}.`) || !viewer.panelId.startsWith(`${extensionId2}.`) || !panels.some((panel) => panel.id === viewer.panelId)) fail$5("manifest.contributes.fileViewers", "requires filePreviews.read and an owned panel");
   }
 }
+const ELEMENT_PICK_INSPECT_PERMISSION = "browserPicks.inspect";
+function parseExtensionElementPickInspectors(value, apiVersion) {
+  if (apiVersion < 4) fail$5("manifest.contributes.elementPickInspectors", "requires Extension API version 4");
+  return contributionList(value, "manifest.contributes.elementPickInspectors", ["id", "title", "script"], (entry, path2) => ({
+    id: id(entry.id, `${path2}.id`),
+    title: string(entry.title, `${path2}.title`),
+    script: relativePath(entry.script, `${path2}.script`, true)
+  }));
+}
+function assertExtensionElementPickInspectors(extensionId2, inspectors, permissions) {
+  if (inspectors.length > 0 !== permissions.includes(ELEMENT_PICK_INSPECT_PERMISSION)) {
+    fail$5("manifest.contributes.elementPickInspectors", `requires ${ELEMENT_PICK_INSPECT_PERMISSION} permission and an inspector that uses it`);
+  }
+  for (const inspector of inspectors) {
+    if (!inspector.id.startsWith(`${extensionId2}.`)) fail$5("manifest.contributes.elementPickInspectors", "expected an id declared by the same extension");
+  }
+}
 function parseMachineCommands(value, extensionId2, apiVersion) {
   if (apiVersion < 3) fail$5("manifest.machineCommands", "requires Extension API version 3");
   const root = record$1(value, "manifest.machineCommands");
@@ -492,6 +596,8 @@ function parseExtensionChannelContributions(value) {
   });
 }
 const EXTENSION_PERMISSIONS = [
+  "sessionContext.read",
+  "sessionContext.subscribe",
   "assets.read",
   "assets.write",
   "files.select",
@@ -514,6 +620,7 @@ const EXTENSION_PERMISSIONS = [
   "browserViewer.installChrome",
   "artifacts.publishPublic",
   "filePreviews.read",
+  "browserPicks.inspect",
   // One permission per channel wire method (`src/domain/channelProtocol.ts`), deliberately not a
   // single adapter grant. Receiving and acking messages is transport work; reading a session,
   // driving it, or approving a tool call once are three larger and separately-refusable
@@ -528,8 +635,9 @@ const EXTENSION_PERMISSIONS = [
   "sessions.control",
   "sessions.approveOnce"
 ];
-const SAYCODE_EXTENSION_API_VERSION = 4;
-const SAYCODE_EXTENSION_MINIMUM_API_VERSION = 2;
+const CONVERSATION_MODS_INTERNAL = typeof __SAYCODE_MODS_INTERNAL__ !== "undefined" && __SAYCODE_MODS_INTERNAL__ === true;
+const SAYCODE_EXTENSION_API_VERSION = CONVERSATION_MODS_INTERNAL ? 5 : 4;
+const SAYCODE_EXTENSION_MINIMUM_API_VERSION = CONVERSATION_MODS_INTERNAL ? 4 : 2;
 const MAX_EXTENSION_API_WINDOW_WIDTH = 2;
 const SAYCODE_EXTENSION_ENGINE_VERSION = "1.2.0";
 const SAYCODE_CHANNEL_API_VERSION = CHANNEL_API_VERSION;
@@ -552,9 +660,8 @@ class UnsupportedExtensionApiVersionError extends Error {
 }
 const SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
 const ENGINE_RANGE_PATTERN = /^(?:\^|~|>=|<=|>|<)?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
-const ENTRYPOINT_PATTERN = /\.(?:cjs|mjs|js)$/;
 const LOCALE_PATTERN = /^[a-z]{2,3}(?:-[A-Z]{2})?$/;
-const CONTRIBUTION_KEYS = /* @__PURE__ */ new Set(["commands", "settings", "panels", "projectTemplates", "machineActions", "projectTools", "artifactActions", "channels", "fileViewers"]);
+const CONTRIBUTION_KEYS = /* @__PURE__ */ new Set(["chatWidgets", "commands", "settings", "panels", "projectTemplates", "machineActions", "projectTools", "artifactActions", "channels", "fileViewers", "elementPickInspectors"]);
 const V2_PERMISSIONS = /* @__PURE__ */ new Set([
   "browserViewer.open",
   "browserViewer.install",
@@ -626,14 +733,6 @@ function parseApiVersion(value, options) {
   }
   return value;
 }
-function relativePath(value, path2, requireScript = false) {
-  const parsed = string(value, path2);
-  const segments = parsed.split("/");
-  if (parsed.startsWith("/") || parsed.includes("\\") || segments.some((segment) => segment === "" || segment === "." || segment === "..") || requireScript && !ENTRYPOINT_PATTERN.test(parsed)) {
-    fail$5(path2, "expected safe relative path");
-  }
-  return parsed;
-}
 function parseChannelApiVersion(value, apiVersion) {
   if (value === void 0) return void 0;
   if (apiVersion < 3) fail$5("manifest.channelApiVersion", "requires Extension API version 3");
@@ -657,6 +756,7 @@ function parseContributions(value, apiVersion, channelApiVersion) {
   }
   const result = {};
   if (parsed.fileViewers !== void 0) result.fileViewers = parseExtensionFileViewers(parsed.fileViewers, apiVersion);
+  if (parsed.elementPickInspectors !== void 0) result.elementPickInspectors = parseExtensionElementPickInspectors(parsed.elementPickInspectors, apiVersion);
   if (parsed.commands !== void 0) {
     result.commands = contributionList(
       parsed.commands,
@@ -762,6 +862,7 @@ function parseContributions(value, apiVersion, channelApiVersion) {
       }
     );
   }
+  if (parsed.chatWidgets !== void 0) result.chatWidgets = parseChatWidgets(parsed.chatWidgets, apiVersion);
   if (parsed.projectTools !== void 0) result.projectTools = parseExtensionProjectTools(parsed.projectTools, apiVersion);
   if (parsed.artifactActions !== void 0) {
     result.artifactActions = parseExtensionArtifactActions(parsed.artifactActions);
@@ -770,6 +871,7 @@ function parseContributions(value, apiVersion, channelApiVersion) {
     result.channels = parseExtensionChannelContributions(parsed.channels);
   }
   const ids = [
+    ...result.chatWidgets ?? [],
     ...result.commands ?? [],
     ...result.settings ?? [],
     ...result.panels ?? [],
@@ -777,7 +879,8 @@ function parseContributions(value, apiVersion, channelApiVersion) {
     ...result.machineActions ?? [],
     ...result.projectTools ?? [],
     ...result.artifactActions ?? [],
-    ...result.channels ?? []
+    ...result.channels ?? [],
+    ...result.elementPickInspectors ?? []
   ].map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) fail$5("manifest.contributes", "duplicate contribution id");
   return result;
@@ -808,7 +911,9 @@ function parseExtensionManifest(value, options) {
       fail$5("manifest.permissions", `unknown permission ${parsed}`);
     }
     const typed = parsed;
+    if (typed.startsWith("sessionContext.") && apiVersion !== 5) fail$5("manifest.permissions", "sessionContext requires API 5");
     if (typed === "filePreviews.read" && apiVersion < 4) fail$5("manifest.permissions", "filePreviews.read requires Extension API version 4");
+    if (typed === "browserPicks.inspect" && apiVersion < 4) fail$5("manifest.permissions", "browserPicks.inspect requires Extension API version 4");
     if (apiVersion < 2 && V2_PERMISSIONS.has(typed)) {
       fail$5(`manifest.permissions[${index}]`, "requires Extension API version 2");
     }
@@ -836,6 +941,12 @@ function parseExtensionManifest(value, options) {
     (event, index) => string(event, `manifest.activationEvents[${index}]`)
   );
   const contributes = parseContributions(manifest.contributes, apiVersion, channelApiVersion);
+  const widgets = contributes.chatWidgets ?? [];
+  const widgetPermissions = permissions.filter((p) => p.startsWith("sessionContext."));
+  if (widgets.length > 0 !== widgetPermissions.length > 0 || widgets.length > 0 && widgetPermissions.length !== 2) fail$5("manifest.contributes.chatWidgets", "requires both sessionContext permissions and widgets");
+  for (const widget of widgets) {
+    if (!widget.id.startsWith(`${parsedId}.`) || !activationEvents.includes(`onChatWidget:${widget.id}`)) fail$5("manifest.contributes.chatWidgets", "requires same-owner id and activation event");
+  }
   if (contributes.channels?.length && !permissions.includes("channels.receive")) {
     fail$5("manifest.contributes.channels", "requires channels.receive permission");
   }
@@ -881,6 +992,7 @@ function parseExtensionManifest(value, options) {
     }
   }
   assertExtensionFileViewers(parsedId, contributes.fileViewers ?? [], contributes.panels ?? [], permissions);
+  assertExtensionElementPickInspectors(parsedId, contributes.elementPickInspectors ?? [], permissions);
   assertExtensionProjectToolTargets(parsedId, contributes.projectTools ?? [], contributes.commands ?? []);
   return {
     id: parsedId,
@@ -989,6 +1101,9 @@ function parseRequest(message) {
   const method = text(message.method, "request.method");
   const params = plainRecord(message.params, "request.params");
   switch (method) {
+    case "widget.render":
+      exactKeys(params, ["widgetId", "snapshot"], "request.params");
+      return { kind: "request", id: id2, method, params: { widgetId: text(params.widgetId, "widgetId"), snapshot: parseWidgetSnapshot(params.snapshot) } };
     case "handshake":
       exactKeys(params, ["apiVersion", "extensionId", "extensionVersion"], "request.params");
       return {
@@ -1027,6 +1142,13 @@ function parseRequest(message) {
         connectionRevision: Number(params.connectionRevision)
       } };
     }
+    case "channel.intake": {
+      exactKeys(params, ["apiVersion", "channelId", "connectionId", "provider", "connectionRevision"], "request.params");
+      const lifecycle = parseRequest({ kind: "request", id: id2, method: "channel.lifecycle", params: { ...params, state: "start" } });
+      if (lifecycle.method !== "channel.lifecycle") fail("invalid channel intake");
+      const { state: _state, ...identity } = lifecycle.params;
+      return { kind: "request", id: id2, method, params: identity };
+    }
     case "channel.formatReply": {
       const formatKeys = [
         "apiVersion",
@@ -1172,8 +1294,10 @@ class ExtensionHostRuntime {
   constructor(options) {
     this.options = options;
   }
+  widgets = /* @__PURE__ */ new Map();
   channelHandlers = /* @__PURE__ */ new Map();
   channelFormatters = /* @__PURE__ */ new Map();
+  channelIntakeHandlers = /* @__PURE__ */ new Map();
   channelStates = /* @__PURE__ */ new Map();
   channelCalls = /* @__PURE__ */ new Map();
   channelEpoch = 0;
@@ -1304,9 +1428,11 @@ class ExtensionHostRuntime {
     } finally {
       this.active = false;
       this.module = null;
+      this.widgets.clear();
       this.commandHandlers.clear();
       this.channelHandlers.clear();
       this.channelFormatters.clear();
+      this.channelIntakeHandlers.clear();
       this.channelStates.clear();
       this.channelCalls.clear();
     }
@@ -1345,9 +1471,11 @@ class ExtensionHostRuntime {
         if (this.active) await this.module?.deactivate?.(request.params.reason);
       } finally {
         this.active = false;
+        this.widgets.clear();
         this.commandHandlers.clear();
         this.channelHandlers.clear();
         this.channelFormatters.clear();
+        this.channelIntakeHandlers.clear();
         this.channelStates.clear();
         this.channelCalls.clear();
         this.deactivating = false;
@@ -1360,8 +1488,14 @@ class ExtensionHostRuntime {
     if (!this.active) {
       throw { code: "NOT_ACTIVE", message: "extension command handler is not active" };
     }
+    if (request.method === "widget.render") {
+      const render = this.widgets.get(request.params.widgetId);
+      if (!render) throw new Error("widget is not registered");
+      return parseWidgetTree(await render(request.params.snapshot));
+    }
     if (request.method === "channel.lifecycle") return this.deliverChannel(request.params);
     if (request.method === "channel.formatReply") return this.formatChannelReply(request.params);
+    if (request.method === "channel.intake") return this.deliverChannelIntake(request.params);
     const handler = this.commandHandlers.get(request.params.commandId);
     if (!handler) {
       throw { code: "COMMAND_NOT_REGISTERED", message: `extension command is not registered: ${request.params.commandId}` };
@@ -1410,6 +1544,14 @@ class ExtensionHostRuntime {
       if (this.channelCalls.get(key) === next) this.channelCalls.delete(key);
     }
   }
+  /** A hint for a live connection only; anything else is answered and dropped, never an error. */
+  async deliverChannelIntake(input) {
+    const current = this.channelStates.get(JSON.stringify([input.channelId, input.connectionId]));
+    const handler = this.channelIntakeHandlers.get(input.channelId);
+    if (!handler || this.deactivating || current?.state !== "start" || current.provider !== input.provider || current.connectionRevision !== input.connectionRevision) return null;
+    await handler(Object.freeze({ ...input }));
+    return null;
+  }
   async formatChannelReply(input) {
     const key = JSON.stringify([input.channelId, input.connectionId]);
     const current = this.channelStates.get(key);
@@ -1450,11 +1592,17 @@ class ExtensionHostRuntime {
         await this.options.loadModule(this.options.manifest.entrypoint)
       );
       if (this.disposed) throw { code: "HOST_DISPOSED", message: "extension host is disposed" };
+      const registeredWidgets = /* @__PURE__ */ new Map();
       const registered = /* @__PURE__ */ new Map();
       const registeredChannels = /* @__PURE__ */ new Map();
       const registeredFormatters = /* @__PURE__ */ new Map();
+      const registeredIntake = /* @__PURE__ */ new Map();
       await loaded.activate({
         extensionId: this.options.manifest.id,
+        chatWidgets: { register: (id2, render) => {
+          if (!this.activating || this.options.manifest.apiVersion !== 5 || !this.options.manifest.contributes.chatWidgets?.some((w) => w.id === id2) || registeredWidgets.has(id2) || typeof render !== "function") throw new Error("invalid widget registration");
+          registeredWidgets.set(id2, render);
+        } },
         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)) {
@@ -1467,6 +1615,12 @@ class ExtensionHostRuntime {
               throw { code: "INVALID_CHANNEL_REGISTRATION", message: "formatter must be declared and registered once" };
             }
             registeredFormatters.set(channelId, formatter);
+          },
+          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)) {
+              throw { code: "INVALID_CHANNEL_REGISTRATION", message: "intake handler must be declared and registered once" };
+            }
+            registeredIntake.set(channelId, handler);
           }
         },
         commands: {
@@ -1482,9 +1636,12 @@ class ExtensionHostRuntime {
         throw { code: "HOST_DISPOSED", message: "extension host is disposed" };
       }
       this.module = loaded;
+      for (const [id2, render] of registeredWidgets) this.widgets.set(id2, render);
       this.channelHandlers.clear();
       this.channelFormatters.clear();
       for (const [id2, formatter] of registeredFormatters) this.channelFormatters.set(id2, formatter);
+      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);
       this.commandHandlers.clear();
       for (const [commandId, handler] of registered) this.commandHandlers.set(commandId, handler);