@buzzni/saycode-cli 0.9.13 → 0.9.14

package/README.md

@@ -594,3 +594,31 @@ ACK 유실·pending은 같은 operation의 `owned-child-status`만 2~10초 간
 기록(`owned-spawns/<operationId>.json`)이 이 세션·scope·예산 key의 것이고 원장에 그 예약이 있을 때만 진행하며, 새 spawn·새 예약·환급은 없습니다.
 started면 원래 spawnId로 lineage를 기록해 `resumedOperation`과 함께 반환하고, 아직이거나 status를 조회할 수 없으면 다시 `spawn_pending`입니다(보고된 실패만 `spawn_failed`). 기록이 없거나 다른 source·scope면 `not_owned`,
 owner contact가 없으면 `owner-contact-unavailable`, 재개 명령이 초기화(인증·연결)조차 못 하면 같은 operation의 `spawn_pending`(`next` 유지)입니다. 다른 spawn 옵션과 함께 쓸 수 없습니다.
+
+### 재개 가능한 seq 관측 (능력 확인 후)
+
+`happy agent whoami`의 `capabilities.resumableObservation.version=1`이 있는 direct CLI에서만 사용한다.
+서버 기능은 기본 비활성이며, 구 facade/server와 현재 broker v1에서는 이 능력을 광고하지 않는다.
+새 옵션 없는 wait/read의 기본 10분 대기와 출력은 유지된다.
+
+```sh
+happy agent wait <id> --until turn-end --after-seq 0 --timeout 45000
+happy agent wait <id> --until turn-end --after-seq 0 --resume <checkpoint> --timeout 45000
+happy agent read <id> --after-seq 0 --through-seq <match-seq> --page-size 100
+```
+
+timeout은 조회·복구·정리를 포함한 한 관측 호출의 예산이다(기본45초, 1~60초).
+작업은 계속되며 부모가 전체 작업 예산을 별도로 유지한다. 재호출은 원래 afterSeq와 checkpoint를 보존한다.
+신규 자식 최초 작업의 기준점은 0이다. 기존 세션은 요청 전에 기준점을 정하고 결과가 해당 요청의 답인지 확인한다.
+read의 다음 페이지는 page.nextSeq를 after-seq로, page.throughSeq를 같은 상한으로 쓴다.
+hasMore=false는 그 구간만 소진했음을 뜻한다. 이후 본문 갱신·추가 메시지를 필요에 따라 다시 읽는다.
+
+완료 사건의 failed/cancelled/blocked 상태는 작업 성공이 아니다. responseFinality는 unknown이다.
+체크포인트는 원문 없는 caller-held DTO이며 인증 토큰이 아니다. 64KiB/미확정256행 상한을 넘으면
+history_incomplete로 끝나고 앞 이력을 버리지 않는다. capability_unavailable은 미지원,
+observation_unavailable은 조회/정리 오류다(대상 조회 실패는 reason=target_lookup_failed, 다른 대상으로 바뀌면 target_changed).
+관측 중 대상이 삭제되거나 scope를 벗어나면 session_not_found(reason=target_not_found), 남긴 이력에 사건 없이
+멈춰 있으면 session_not_running(reason=target_inactive)이다. 서버 계약 확인 자체가 실패하면 observation_unavailable(reason=capability_check_failed)다.
+잘못된 옵션 조합은 invalid_arguments, 이력 조회가 거절되면 access_denied(reason=credential_rejected|history_forbidden)이며
+같은 호출을 재시도해도 바뀌지 않는다. 첫 페이지 전에 예산이 끝난 wait_timeout도 afterSeq와 받은 checkpoint를 그대로 돌려준다. 모두 ok=false, exit3이며 작업을 자동 stop/prompt/spawn하지 않는다.
+실제 설치판·broker·10분 이상 작업 수락은 기능 spec의 남은 검증 항목을 따른다.

package/channel-extension-host.mjs

@@ -71,7 +71,7 @@ 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) {
+function bounded$1(value) {
   const encoded = JSON.stringify(value);
   if (!encoded || new TextEncoder().encode(encoded).length > 32768) fail$5("widget", "payload exceeds 32 KiB");
 }
@@ -104,7 +104,7 @@ function parseWidgetTree(value) {
     return { type: "list", children: node.children.map((child) => walk(child, depth + 1)) };
   };
   const result = walk(value, 1);
-  bounded(result);
+  bounded$1(result);
   return result;
 }
 function parseWidgetSnapshot(value) {
@@ -132,7 +132,7 @@ function parseWidgetSnapshot(value) {
     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);
+  bounded$1(result);
   return result;
 }
 function parseExtensionFileViewers(value, apiVersion) {
@@ -389,6 +389,214 @@ function assertExtensionProjectToolTargets(extensionId2, tools, commands) {
     if (!command.panelId) fail$5(`${path2}.command`, "expected a command that opens a panel");
   }
 }
+const SESSION_HOOK_ACTIVATION_PREFIX = "onSessionOpenBefore:";
+const MAX_HOOKS = 4;
+const MAX_ENV = 32;
+const MAX_SERVERS = 8;
+const MAX_ARGS = 32;
+const MAX_COPY = 32;
+const ENV_NAME = /^[A-Z][A-Z0-9_]{0,63}$/;
+const SERVER_NAME = /^[a-z][a-z0-9_-]{0,31}$/;
+const HEADER_NAME = /^[A-Za-z0-9-]{1,64}$/;
+const COMMAND = /^[a-z][a-z0-9._-]{0,63}$/;
+const RESERVED_ENV = /* @__PURE__ */ new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "PWD",
+  "TMPDIR",
+  "TERM",
+  "PORT",
+  "SSH_AUTH_SOCK",
+  "IFS",
+  "PS4",
+  "PROMPT_COMMAND",
+  "ENV",
+  "BASH_ENV",
+  "ZDOTDIR",
+  "SHELLOPTS",
+  "BASHOPTS",
+  "COMSPEC",
+  "PATHEXT",
+  "PYTHONPATH",
+  "PYTHONHOME",
+  "PYTHONSTARTUP",
+  "PERL5LIB",
+  "PERL5OPT",
+  "PERLLIB",
+  "RUBYOPT",
+  "RUBYLIB",
+  "JAVA_TOOL_OPTIONS",
+  "_JAVA_OPTIONS",
+  "JDK_JAVA_OPTIONS",
+  "GCONV_PATH"
+]);
+const RESERVED_ENV_PREFIXES = ["HAPPY_", "SAYCODE_", "APLUS_", "LD_", "DYLD_", "GIT_", "ANTHROPIC_", "CLAUDE_", "OPENAI_", "CODEX_", "NODE_", "NPM_CONFIG_", "BASH_FUNC_"];
+const RESERVED_SERVER_PREFIXES = ["happy", "saycode", "aplus"];
+const RESERVED_SERVER_NAMES = /* @__PURE__ */ new Set(["cua-driver"]);
+const UNSUPPORTED_COMMANDS = /^(sh|bash|zsh|fish|dash|ksh|csh|tcsh|cmd|powershell|pwsh|wsl|env|xargs|ssh|tmux|screen|osascript|sudo|su|doas|nohup|awk|gawk|eval|exec|start|cscript|wscript|mshta|rundll32)$/;
+const INTERPRETERS = /^(node|nodejs|deno|bun|python[0-9.]*|py|ruby|perl|php)$/;
+const RUNNERS = /^(npx|pnpx|bunx|uvx|uv|pipx|yarn|pnpm|npm|deno|bun)$/;
+const EVAL_SUBCOMMANDS = /* @__PURE__ */ new Set(["eval", "repl"]);
+const INLINE_CODE_FLAGS = /^(-[eEcpr]|--(eval|print|import|require|loader|experimental-loader|call|shell|command))(=|$)|^-[eEcp]./;
+const RUNNER_SHELL_FLAGS = /^(-c|--call|--shell|--shell-auto-fallback|exec)(=|$)/;
+function programName(command) {
+  return command.toLowerCase().replace(/\.(exe|cmd|bat|com|ps1)$/, "");
+}
+function isReservedLaunchEnvName(name) {
+  return RESERVED_ENV.has(name) || RESERVED_ENV_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+function isReservedLaunchMcpServerName(name) {
+  return RESERVED_SERVER_NAMES.has(name) || RESERVED_SERVER_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+function bounded(items, max, path2, min = 0) {
+  if (items.length < min || items.length > max) fail$5(path2, `expected ${min} to ${max} entries`);
+  return items;
+}
+function envName(value, path2) {
+  const name = string(value, path2);
+  if (!ENV_NAME.test(name)) fail$5(path2, "expected an upper-case environment variable name");
+  if (isReservedLaunchEnvName(name)) fail$5(path2, `reserved name ${name}`);
+  return name;
+}
+function parseEnv(value, path2) {
+  return bounded(contributionList(value, path2, ["name", "secret"], (entry, entryPath) => {
+    if (entry.secret !== void 0 && entry.secret !== true) fail$5(`${entryPath}.secret`, "expected true when present");
+    return { name: envName(entry.name, `${entryPath}.name`), ...entry.secret === true ? { secret: true } : {} };
+  }), MAX_ENV, path2);
+}
+function parseArgs(command, value, path2) {
+  const args = bounded(array(value, path2), MAX_ARGS, path2).map((arg, index) => {
+    if (typeof arg !== "string" || arg.length > 512 || arg.includes("\0")) fail$5(`${path2}[${index}]`, "expected a string up to 512 characters");
+    return arg;
+  });
+  const words = [command, ...args];
+  const interpreterAt = words.findIndex((word) => INTERPRETERS.test(programName(word)));
+  const inline = interpreterAt >= 0 && words.slice(interpreterAt + 1).some((arg) => INLINE_CODE_FLAGS.test(arg) || EVAL_SUBCOMMANDS.has(arg));
+  const runnerShell = RUNNERS.test(programName(command)) && args.some((arg) => RUNNER_SHELL_FLAGS.test(arg) || EVAL_SUBCOMMANDS.has(arg));
+  if (inline || runnerShell) fail$5(path2, "inline code is not allowed; run a published package or file");
+  return args;
+}
+function parseUrl(value, path2) {
+  const url = string(value, path2);
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    fail$5(path2, "expected an https URL");
+  }
+  if (parsed.protocol !== "https:" || parsed.username || parsed.password || url.length > 2048) fail$5(path2, "expected an https URL without credentials");
+  return url;
+}
+function parseServer(entry, path2, env) {
+  const name = string(entry.name, `${path2}.name`);
+  if (!SERVER_NAME.test(name)) fail$5(`${path2}.name`, "expected a lower-case server name");
+  if (isReservedLaunchMcpServerName(name)) fail$5(`${path2}.name`, `reserved name ${name}`);
+  const declared = new Set(env.map((item) => item.name));
+  if (entry.transport === "stdio") {
+    assertOnlyKeys(entry, /* @__PURE__ */ new Set(["name", "transport", "command", "args", "envNames"]), path2);
+    const command = string(entry.command, `${path2}.command`);
+    if (!COMMAND.test(command) || UNSUPPORTED_COMMANDS.test(programName(command))) fail$5(`${path2}.command`, "unsupported command");
+    const args = entry.args === void 0 ? void 0 : parseArgs(command, entry.args, `${path2}.args`);
+    const envNames = entry.envNames === void 0 ? void 0 : array(entry.envNames, `${path2}.envNames`).map((item, index) => {
+      const itemName = string(item, `${path2}.envNames[${index}]`);
+      if (!declared.has(itemName)) fail$5(`${path2}.envNames[${index}]`, "expected an env name declared by the same hook");
+      return itemName;
+    });
+    return { name, transport: "stdio", command, ...args ? { args } : {}, ...envNames ? { envNames } : {} };
+  }
+  if (entry.transport === "http") {
+    assertOnlyKeys(entry, /* @__PURE__ */ new Set(["name", "transport", "url", "headerEnvNames"]), path2);
+    const url = parseUrl(entry.url, `${path2}.url`);
+    let headerEnvNames;
+    if (entry.headerEnvNames !== void 0) {
+      const headers = Object.entries(record$1(entry.headerEnvNames, `${path2}.headerEnvNames`));
+      bounded(headers, MAX_SERVERS, `${path2}.headerEnvNames`);
+      headerEnvNames = {};
+      for (const [header, raw] of headers) {
+        const target = string(raw, `${path2}.headerEnvNames.${header}`);
+        if (!HEADER_NAME.test(header)) fail$5(`${path2}.headerEnvNames`, `invalid header ${header}`);
+        if (!env.some((item) => item.name === target && item.secret)) fail$5(`${path2}.headerEnvNames.${header}`, "expected a secret env declared by the same hook");
+        headerEnvNames[header] = target;
+      }
+    }
+    return { name, transport: "http", url, ...headerEnvNames ? { headerEnvNames } : {} };
+  }
+  fail$5(`${path2}.transport`, "expected stdio or http");
+}
+function parseExtensionSessionHooks(value, apiVersion) {
+  const path2 = "manifest.contributes.sessionHooks";
+  if (apiVersion < 4) fail$5(path2, "requires Extension API version 4");
+  const hooks = contributionList(value, path2, ["id", "event", "scope", "dynamic", "env", "mcpServers"], (entry, entryPath) => {
+    if (entry.event !== "session.open.before") fail$5(`${entryPath}.event`, "expected session.open.before");
+    if (entry.scope !== void 0 && entry.scope !== "all" && entry.scope !== "company") fail$5(`${entryPath}.scope`, "expected all or company");
+    if (entry.dynamic !== void 0 && entry.dynamic !== true) fail$5(`${entryPath}.dynamic`, "expected true when present");
+    const env = entry.env === void 0 ? [] : parseEnv(entry.env, `${entryPath}.env`);
+    const servers = entry.mcpServers === void 0 ? [] : bounded(contributionList(
+      entry.mcpServers,
+      `${entryPath}.mcpServers`,
+      ["name", "transport", "command", "args", "envNames", "url", "headerEnvNames"],
+      (server, serverPath) => parseServer(server, serverPath, env)
+    ), MAX_SERVERS, `${entryPath}.mcpServers`);
+    if (env.length === 0 && servers.length === 0) fail$5(entryPath, "expected env or mcpServers to inject");
+    return {
+      id: id(entry.id, `${entryPath}.id`),
+      event: "session.open.before",
+      ...entry.scope === void 0 ? {} : { scope: entry.scope },
+      ...entry.dynamic === true ? { dynamic: true } : {},
+      ...entry.env === void 0 ? {} : { env },
+      ...entry.mcpServers === void 0 ? {} : { mcpServers: servers }
+    };
+  });
+  bounded(hooks, MAX_HOOKS, path2);
+  const envNames = /* @__PURE__ */ new Set();
+  const serverNames = /* @__PURE__ */ new Set();
+  for (const hook of hooks) {
+    for (const item of hook.env ?? []) {
+      if (envNames.has(item.name)) fail$5(path2, `duplicate env name ${item.name}`);
+      envNames.add(item.name);
+    }
+    for (const server of hook.mcpServers ?? []) {
+      if (serverNames.has(server.name)) fail$5(path2, `duplicate MCP server name ${server.name}`);
+      serverNames.add(server.name);
+    }
+  }
+  return hooks;
+}
+function parseExtensionWorktreeHooks(value, apiVersion) {
+  const path2 = "manifest.contributes.worktreeHooks";
+  if (apiVersion < 4) fail$5(path2, "requires Extension API version 4");
+  return bounded(contributionList(value, path2, ["id", "event", "copyIgnored"], (entry, entryPath) => {
+    if (entry.event !== "worktree.create.after") fail$5(`${entryPath}.event`, "expected worktree.create.after");
+    const copyIgnored = bounded(array(entry.copyIgnored, `${entryPath}.copyIgnored`), MAX_COPY, `${entryPath}.copyIgnored`, 1).map((raw, index) => {
+      const itemPath = `${entryPath}.copyIgnored[${index}]`;
+      const relative = relativePath(raw, itemPath);
+      if (relative.length > 512 || relative.split("/").includes(".git")) fail$5(itemPath, "expected a path outside .git");
+      return relative;
+    });
+    return { id: id(entry.id, `${entryPath}.id`), event: "worktree.create.after", copyIgnored };
+  }), MAX_HOOKS, path2);
+}
+function assertExtensionLaunchHooks(input) {
+  const pairs = [
+    ["sessionHooks", "sessions.launchEnvironment", input.sessionHooks],
+    ["worktreeHooks", "worktrees.prepare", input.worktreeHooks]
+  ];
+  for (const [key, permission, hooks] of pairs) {
+    if (hooks.length > 0 && !input.permissions.includes(permission)) fail$5(`manifest.contributes.${key}`, `requires ${permission} permission`);
+    if (hooks.length === 0 && input.permissions.includes(permission)) fail$5("manifest.permissions", `${permission} requires a ${key} contribution`);
+    for (const [index, hook] of hooks.entries()) {
+      if (!hook.id.startsWith(`${input.extensionId}.`)) fail$5(`manifest.contributes.${key}[${index}].id`, "expected an id declared by the same extension");
+    }
+  }
+  for (const [index, hook] of input.sessionHooks.entries()) {
+    if (hook.dynamic && !input.activationEvents.includes(`${SESSION_HOOK_ACTIVATION_PREFIX}${hook.id}`)) {
+      fail$5(`manifest.contributes.sessionHooks[${index}].dynamic`, `requires activation event ${SESSION_HOOK_ACTIVATION_PREFIX}${hook.id}`);
+    }
+  }
+}
 const EXTENSION_ARTIFACT_ACTION_OPERATIONS = ["publishPublic"];
 const EXTENSION_ARTIFACT_SOURCE_TYPES = ["project-file", "personal-chat-file"];
 const ID_PATTERN$1 = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
@@ -657,13 +865,16 @@ const EXTENSION_PERMISSIONS = [
   // 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"
+  "channels.normalize",
+  // specs/extension-session-and-worktree-hooks — env·MCP at session open, and copying ignored files into a new worktree.
+  "sessions.launchEnvironment",
+  "worktrees.prepare"
 ];
 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.3.0";
+const SAYCODE_EXTENSION_ENGINE_VERSION = "1.4.0";
 const SAYCODE_CHANNEL_API_VERSION = CHANNEL_API_VERSION;
 const SAYCODE_CHANNEL_MINIMUM_API_VERSION = CHANNEL_MINIMUM_API_VERSION;
 class UnsupportedChannelApiVersionError extends Error {
@@ -685,7 +896,7 @@ 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 LOCALE_PATTERN = /^[a-z]{2,3}(?:-[A-Z]{2})?$/;
-const CONTRIBUTION_KEYS = /* @__PURE__ */ new Set(["chatWidgets", "commands", "settings", "panels", "projectTemplates", "machineActions", "projectTools", "artifactActions", "channels", "fileViewers", "elementPickInspectors"]);
+const CONTRIBUTION_KEYS = /* @__PURE__ */ new Set(["chatWidgets", "commands", "settings", "panels", "projectTemplates", "machineActions", "projectTools", "artifactActions", "channels", "fileViewers", "elementPickInspectors", "sessionHooks", "worktreeHooks"]);
 const V2_PERMISSIONS = /* @__PURE__ */ new Set([
   "browserViewer.open",
   "browserViewer.install",
@@ -895,6 +1106,8 @@ function parseContributions(value, apiVersion, channelApiVersion) {
   if (parsed.channels !== void 0) {
     result.channels = parseExtensionChannelContributions(parsed.channels);
   }
+  if (parsed.sessionHooks !== void 0) result.sessionHooks = parseExtensionSessionHooks(parsed.sessionHooks, apiVersion);
+  if (parsed.worktreeHooks !== void 0) result.worktreeHooks = parseExtensionWorktreeHooks(parsed.worktreeHooks, apiVersion);
   const ids = [
     ...result.chatWidgets ?? [],
     ...result.commands ?? [],
@@ -905,7 +1118,9 @@ function parseContributions(value, apiVersion, channelApiVersion) {
     ...result.projectTools ?? [],
     ...result.artifactActions ?? [],
     ...result.channels ?? [],
-    ...result.elementPickInspectors ?? []
+    ...result.elementPickInspectors ?? [],
+    ...result.sessionHooks ?? [],
+    ...result.worktreeHooks ?? []
   ].map((entry) => entry.id);
   if (new Set(ids).size !== ids.length) fail$5("manifest.contributes", "duplicate contribution id");
   return result;
@@ -939,6 +1154,7 @@ function parseExtensionManifest(value, options) {
     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 ((typed === "sessions.launchEnvironment" || typed === "worktrees.prepare") && apiVersion < 4) fail$5("manifest.permissions", `${typed} requires Extension API version 4`);
     if (apiVersion < 2 && V2_PERMISSIONS.has(typed)) {
       fail$5(`manifest.permissions[${index}]`, "requires Extension API version 2");
     }
@@ -1022,6 +1238,13 @@ function parseExtensionManifest(value, options) {
   assertExtensionFileViewers(parsedId, contributes.fileViewers ?? [], contributes.panels ?? [], permissions);
   assertExtensionElementPickInspectors(parsedId, contributes.elementPickInspectors ?? [], permissions);
   assertExtensionProjectToolTargets(parsedId, contributes.projectTools ?? [], contributes.commands ?? []);
+  assertExtensionLaunchHooks({
+    extensionId: parsedId,
+    permissions,
+    activationEvents,
+    sessionHooks: contributes.sessionHooks ?? [],
+    worktreeHooks: contributes.worktreeHooks ?? []
+  });
   return {
     id: parsedId,
     version,
@@ -1341,6 +1564,40 @@ function sameJson(a, b) {
 }
 const utf8Bytes = (text2) => new TextEncoder().encode(text2).length;
 const hasLoneSurrogate = (text2) => /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(text2);
+const SESSION_KINDS = /* @__PURE__ */ new Set(["chat", "child", "automation", "channel"]);
+const SHORT_TEXT = /^[^\u0000-\u001f]{1,200}$/;
+function shortText(value) {
+  return typeof value === "string" && SHORT_TEXT.test(value);
+}
+function onlyKeys(value, keys2) {
+  return Object.keys(value).every((key) => keys2.includes(key));
+}
+function plain(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseSessionOpenBeforeInput(value) {
+  const invalid = () => {
+    throw new Error("invalid session.openBefore input");
+  };
+  if (!plain(value) || !onlyKeys(value, ["reason", "sessionKind", "agent", "project"])) invalid();
+  const input = value;
+  if (input.reason !== "create" && input.reason !== "resume" || !SESSION_KINDS.has(String(input.sessionKind)) || !shortText(input.agent)) invalid();
+  const project = input.project;
+  if (!plain(project) || !onlyKeys(project, ["id", "companyId", "repository"]) || !shortText(project.id) || project.companyId !== void 0 && !shortText(project.companyId)) invalid();
+  const repository = project.repository;
+  if (repository !== void 0 && (!plain(repository) || !onlyKeys(repository, ["name", "remoteHost"]) || !shortText(repository.name) || repository.remoteHost !== void 0 && !shortText(repository.remoteHost))) invalid();
+  const typedProject = project;
+  return {
+    reason: input.reason,
+    sessionKind: input.sessionKind,
+    agent: input.agent,
+    project: {
+      id: typedProject.id,
+      ...typedProject.companyId ? { companyId: typedProject.companyId } : {},
+      ...typedProject.repository ? { repository: { name: typedProject.repository.name, ...typedProject.repository.remoteHost ? { remoteHost: typedProject.repository.remoteHost } : {} } } : {}
+    }
+  };
+}
 function finiteNumber(value, path2) {
   if (typeof value !== "number" || !Number.isFinite(value)) fail(`${path2} must be a finite number`);
   return value;
@@ -1474,6 +1731,9 @@ function parseRequest(message) {
     }
     case "channel.normalizeMessages":
       return { kind: "request", id: id2, method, params: parseChannelNormalizeRequest(params) };
+    case "session.openBefore":
+      exactKeys(params, ["hookId", "input"], "request.params");
+      return { kind: "request", id: id2, method, params: { hookId: text(params.hookId, "request.params.hookId"), input: parseSessionOpenBeforeInput(params.input) } };
     case "invokeCommand": {
       exactKeys(params, ["commandId", "args"], "request.params");
       if (!Array.isArray(params.args)) fail("request.params.args must be an array");
@@ -1602,6 +1862,7 @@ class ExtensionHostRuntime {
   activation = null;
   module = null;
   commandHandlers = /* @__PURE__ */ new Map();
+  sessionOpenHandlers = /* @__PURE__ */ new Map();
   ongoingRequestIds = /* @__PURE__ */ new Set();
   respondedIds = /* @__PURE__ */ new Set();
   pendingCapabilityRequests = /* @__PURE__ */ new Map();
@@ -1722,6 +1983,7 @@ class ExtensionHostRuntime {
       this.module = null;
       this.widgets.clear();
       this.commandHandlers.clear();
+      this.sessionOpenHandlers.clear();
       this.channelHandlers.clear();
       this.channelFormatters.clear();
       this.channelNormalizers.clear();
@@ -1766,6 +2028,7 @@ class ExtensionHostRuntime {
         this.active = false;
         this.widgets.clear();
         this.commandHandlers.clear();
+        this.sessionOpenHandlers.clear();
         this.channelHandlers.clear();
         this.channelFormatters.clear();
         this.channelNormalizers.clear();
@@ -1791,6 +2054,13 @@ class ExtensionHostRuntime {
     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);
+    if (request.method === "session.openBefore") {
+      const handler2 = this.sessionOpenHandlers.get(request.params.hookId);
+      if (!handler2) throw { code: "SESSION_HOOK_NOT_REGISTERED", message: "session hook handler is not registered" };
+      const validated2 = parseExtensionWireMessage({ kind: "response", id: "result", ok: true, result: await handler2(Object.freeze({ ...request.params.input })) });
+      if (validated2.kind !== "response" || !validated2.ok) throw new Error("extension returned an invalid result");
+      return validated2.result;
+    }
     const handler = this.commandHandlers.get(request.params.commandId);
     if (!handler) {
       throw { code: "COMMAND_NOT_REGISTERED", message: `extension command is not registered: ${request.params.commandId}` };
@@ -1906,6 +2176,7 @@ class ExtensionHostRuntime {
       const registeredFormatters = /* @__PURE__ */ new Map();
       const registeredNormalizers = /* @__PURE__ */ new Map();
       const registeredIntake = /* @__PURE__ */ new Map();
+      const registeredSessionHooks = /* @__PURE__ */ new Map();
       await loaded.activate({
         extensionId: this.options.manifest.id,
         chatWidgets: { register: (id2, render) => {
@@ -1945,6 +2216,14 @@ class ExtensionHostRuntime {
             registered.set(commandId, handler);
           }
         },
+        sessionHooks: {
+          onOpenBefore: (hookId, handler) => {
+            if (!this.activating || !this.options.manifest.contributes.sessionHooks?.some((hook) => hook.id === hookId && hook.dynamic) || typeof handler !== "function" || registeredSessionHooks.has(hookId)) {
+              throw { code: "INVALID_SESSION_HOOK_REGISTRATION", message: "session hook must be a declared dynamic hook and registered once" };
+            }
+            registeredSessionHooks.set(hookId, handler);
+          }
+        },
         invokeCapability: (permission, action, args) => this.invokeCapability(permission, action, args)
       });
       if (this.disposed) {
@@ -1963,6 +2242,8 @@ class ExtensionHostRuntime {
       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);
+      this.sessionOpenHandlers.clear();
+      for (const [hookId, handler] of registeredSessionHooks) this.sessionOpenHandlers.set(hookId, handler);
       this.active = true;
     } finally {
       this.activating = false;