@agentknight/sdk 0.9.42 → 0.9.44

package/dist/index.js

@@ -4,12 +4,12 @@ import {
   PeerChatRequestSchema,
   PeerChatResultSchema,
   validateDataDirectory
-} from "./chunks/chunk-QN3OD5UE.js";
+} from "./chunks/chunk-ZGO2OSQZ.js";
 import {
   AgentSelectionSchema,
   assertSelectionSnapshotFits,
   supportsAgentSelection
-} from "./chunks/chunk-ASHXZ46V.js";
+} from "./chunks/chunk-4UAMAGVT.js";
 import {
   ConversationNormalizer,
   LiveTimelineProjection,
@@ -31,26 +31,33 @@ import {
   resolveGitProjectIdentity,
   sessionRestoreFailure,
   validateOperationResponse
-} from "./chunks/chunk-SHOE7YAU.js";
+} from "./chunks/chunk-EWXFUECA.js";
 import {
   GROUP_CHAT_MAX_TURNS,
   GroupChatError
-} from "./chunks/chunk-VDC4G7ZG.js";
+} from "./chunks/chunk-LRSHP7WN.js";
+import {
+  detectClaude,
+  detectCopilot,
+  detectPi,
+  hasLocalExecutable
+} from "./chunks/chunk-EIFNERXM.js";
 import {
   assistantPreview,
   isContentfulAssistant,
   userPreview
-} from "./chunks/chunk-RBULXS7T.js";
+} from "./chunks/chunk-AK3YVBEP.js";
 import {
   AgentModelListingError,
   AgentSessionRenameError,
+  CODING_AGENT_IDS,
   SessionOperationError,
   SessionOperations,
   TimelinePageBudgetError,
   UnsupportedAgentOperationError,
   captureResearchAccess,
   captureWorkbenchAccess
-} from "./chunks/chunk-LQIW4ARE.js";
+} from "./chunks/chunk-UNRPSTRM.js";
 import {
   A2aRelayRequestSchema,
   A2aRelayResponseSchema,
@@ -105,6 +112,9 @@ import {
   SESSION_DIRECTORY_MAX_ENTRIES,
   SESSION_DIRECTORY_MAX_RESPONSE_BYTES,
   SESSION_FILE_ATTACHMENTS_CAPABILITY,
+  SESSION_FILE_DOWNLOAD_MAX_ORIGINAL_BYTES,
+  SESSION_FILE_DOWNLOAD_OPERATION,
+  SESSION_FILE_DOWNLOAD_VERSION,
   SESSION_FILE_GZIP_THRESHOLD_BYTES,
   SESSION_FILE_MAX_IMAGE_BYTES,
   SESSION_FILE_MAX_IMAGE_EDGE,
@@ -121,6 +131,7 @@ import {
   SESSION_GIT_DIFF_MAX_PATCH_BYTES,
   SESSION_GIT_DIFF_MAX_RESPONSE_BYTES,
   SESSION_GIT_DIFF_OPERATION,
+  SESSION_GIT_DIFF_PARTIAL_VERSION,
   SESSION_GIT_DIFF_VERSION,
   SESSION_IMAGE_API_PATH,
   SESSION_IMAGE_MAX_BYTES,
@@ -152,11 +163,14 @@ import {
   SessionDeleteRequestSchema,
   SessionDirectoryListDataSchema,
   SessionDirectoryListResultDataSchema,
+  SessionFileDownloadDataSchema,
+  SessionFileDownloadResultDataSchema,
   SessionFileReadDataSchema,
   SessionFileReadResultDataSchema,
   SessionFileReadV2ResultDataSchema,
   SessionGitDiffDataSchema,
   SessionGitDiffGzipResultDataSchema,
+  SessionGitDiffPartialResultDataSchema,
   SessionGitDiffResultDataSchema,
   SessionImageCommitResultSchema,
   SessionImageScopeSchema,
@@ -227,7 +241,7 @@ import {
   sessionCommunicationError,
   sessionCommunicationOperationCapability,
   workbenchCapability
-} from "./chunks/chunk-QTBB2U7G.js";
+} from "./chunks/chunk-W6TZVD7W.js";
 
 // src/initialize.ts
 import { createHash as createHash16 } from "node:crypto";
@@ -244,6 +258,8 @@ var genericIcon = '<svg viewBox="0 0 24 24" aria-hidden="true" focusable="false"
 var presentations = {
   copilot: { name: "GitHub Copilot", icon: copilotIcon },
   pi: { name: "PI", icon: piIcon },
+  codex: { name: "Codex", icon: genericIcon },
+  claude: { name: "Claude Code", icon: genericIcon },
   acp: { name: "ACP", icon: genericIcon }
 };
 var fallback = { name: "Agent", icon: genericIcon };
@@ -251,48 +267,6 @@ function codingAgentPresentation(agentId) {
   return Object.hasOwn(presentations, agentId) ? presentations[agentId] : fallback;
 }
 
-// src/local-agent-discovery.ts
-import { constants } from "node:fs";
-import { access, stat } from "node:fs/promises";
-import { homedir } from "node:os";
-import { delimiter, isAbsolute, join } from "node:path";
-import { fileURLToPath } from "node:url";
-async function accessible(path, executable = false) {
-  try {
-    await access(path, executable && process.platform !== "win32" ? constants.X_OK : constants.F_OK);
-    return (await stat(path)).isFile();
-  } catch (error) {
-    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) return false;
-    throw error;
-  }
-}
-async function hasLocalExecutable(command, environment2 = process.env) {
-  const extensions = process.platform === "win32" ? ["", ...(environment2.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")] : [""];
-  const paths = isAbsolute(command) || command.includes("/") || command.includes("\\") ? [command] : (environment2.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => join(directory, command));
-  for (const path of paths) {
-    for (const extension of extensions) {
-      if (await accessible(`${path}${extension}`, true)) return true;
-    }
-  }
-  return false;
-}
-async function hasPackage(name) {
-  try {
-    return await accessible(fileURLToPath(import.meta.resolve(name)));
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ERR_MODULE_NOT_FOUND") return false;
-    throw error;
-  }
-}
-async function detectCopilot() {
-  return process.env.COPILOT_CLI_PATH ? accessible(process.env.COPILOT_CLI_PATH) : await hasPackage("@github/copilot/npm-loader.js") || hasLocalExecutable("copilot");
-}
-async function detectPi(agentDirectory) {
-  if (!await hasPackage("@earendil-works/pi-coding-agent")) return false;
-  const directory = agentDirectory ?? (process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent"));
-  return agentDirectory !== void 0 || await accessible(join(directory, "auth.json")) || await hasLocalExecutable("pi");
-}
-
 // src/coding-agent-factory.ts
 function assertPiRuntimeSupported(nodeVersion = process.versions.node) {
   const [major, minor] = nodeVersion.split(".").map(Number);
@@ -305,7 +279,7 @@ async function createCodingAgentAdapter(config, onDiagnostic, owner) {
   switch (engine.kind) {
     case "managed": {
       if (owner === void 0) throw new Error("Managed coding agents require the PC owner identity");
-      const { ManagedCodingAgentAdapter } = await import("./chunks/managed-agent-adapter-LMHQX6IH.js");
+      const { ManagedCodingAgentAdapter } = await import("./chunks/managed-agent-adapter-HDLOSSHZ.js");
       return new ManagedCodingAgentAdapter({
         dataDirectory: config.dataDirectory,
         owner,
@@ -331,6 +305,24 @@ async function createCodingAgentAdapter(config, onDiagnostic, owner) {
               }
             }, onDiagnostic)
           },
+          {
+            id: "codex",
+            name: codingAgentPresentation("codex").name,
+            detect: () => hasLocalExecutable(engine.codexCommand ?? "codex"),
+            create: () => createCodingAgentAdapter({
+              ...config,
+              codingAgent: {
+                kind: "codex",
+                ...engine.codexCommand === void 0 ? {} : { command: engine.codexCommand }
+              }
+            }, onDiagnostic)
+          },
+          {
+            id: "claude",
+            name: codingAgentPresentation("claude").name,
+            detect: detectClaude,
+            create: () => createCodingAgentAdapter({ ...config, codingAgent: { kind: "claude" } }, onDiagnostic)
+          },
           {
             id: "acp",
             name: codingAgentPresentation("acp").name,
@@ -344,7 +336,7 @@ async function createCodingAgentAdapter(config, onDiagnostic, owner) {
       });
     }
     case "copilot": {
-      const { GithubCopilotAdapter } = await import("./chunks/copilot-adapter-A6QB4RD4.js");
+      const { GithubCopilotAdapter } = await import("./chunks/copilot-adapter-Y5W4ZUFD.js");
       if (owner !== void 0) {
         return new GithubCopilotAdapter(void 0, void 0, void 0, {
           dataDirectory: config.dataDirectory,
@@ -364,13 +356,28 @@ async function createCodingAgentAdapter(config, onDiagnostic, owner) {
     }
     case "pi": {
       assertPiRuntimeSupported();
-      const { PiCodingAgentAdapter } = await import("./chunks/pi-adapter-NWQWUNXO.js");
+      const { PiCodingAgentAdapter } = await import("./chunks/pi-adapter-6EF6Z5CP.js");
       return new PiCodingAgentAdapter(
         engine.agentDirectory === void 0 ? {} : { agentDirectory: resolve(engine.agentDirectory) }
       );
     }
+    case "codex": {
+      const { CodexCodingAgentAdapter } = await import("./chunks/codex-adapter-MMQK47KY.js");
+      return new CodexCodingAgentAdapter({
+        dataDirectory: resolve(config.dataDirectory, "coding-agents"),
+        ...engine.command === void 0 ? {} : { command: engine.command },
+        ...onDiagnostic === void 0 ? {} : { onDiagnostic }
+      });
+    }
+    case "claude": {
+      const { ClaudeCodingAgentAdapter } = await import("./chunks/claude-adapter-A5EFNV5S.js");
+      return new ClaudeCodingAgentAdapter({
+        dataDirectory: resolve(config.dataDirectory, "coding-agents"),
+        ...onDiagnostic === void 0 ? {} : { onDiagnostic }
+      });
+    }
     case "acp": {
-      const { AcpCodingAgentAdapter } = await import("./chunks/acp-adapter-SPIMGGL2.js");
+      const { AcpCodingAgentAdapter } = await import("./chunks/acp-adapter-JKSOVQJ7.js");
       return new AcpCodingAgentAdapter({
         command: engine.command,
         args: engine.args,
@@ -413,7 +420,7 @@ import {
   writeFileSync
 } from "node:fs";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { join } from "node:path";
 import { z as z2 } from "zod";
 var KEY_BYTES = 32;
 var NONCE_BYTES = 12;
@@ -480,7 +487,7 @@ function generateContentKey() {
   return parseContentKey(randomBytes(KEY_BYTES).toString("base64url"));
 }
 async function loadOrCreateContentKey(dataDirectory) {
-  const path = join2(dataDirectory, "content-key.json");
+  const path = join(dataDirectory, "content-key.json");
   await mkdir(dataDirectory, { recursive: true });
   try {
     const stored = ContentKeyFileSchema.parse(
@@ -509,7 +516,7 @@ async function loadOrCreateContentKey(dataDirectory) {
 }
 async function createPersistentContentCipher(dataDirectory, key) {
   await mkdir(dataDirectory, { recursive: true });
-  const path = join2(dataDirectory, "content-replay.log");
+  const path = join(dataDirectory, "content-replay.log");
   let processedMessages = /* @__PURE__ */ new Map();
   let compactOnNextWrite = false;
   try {
@@ -861,15 +868,15 @@ import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 
 // src/research-tools.ts
 import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
-import { lstat as lstat3, realpath as realpath3, stat as stat4 } from "node:fs/promises";
-import { isAbsolute as isAbsolute4, join as join5 } from "node:path";
+import { lstat as lstat3, realpath as realpath3, stat as stat3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3, join as join4 } from "node:path";
 import { gunzipSync } from "node:zlib";
 import { z as z5 } from "zod";
 
 // src/session-directory.ts
 import { createHash as createHash2 } from "node:crypto";
-import { lstat, opendir, realpath, stat as stat2 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join3, relative, sep } from "node:path";
+import { lstat, opendir, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join as join2, relative, sep } from "node:path";
 var SESSION_DIRECTORY_CONCURRENCY = 4;
 var SESSION_DIRECTORY_TIMEOUT_MS = 5e3;
 var SessionDirectoryError = class extends Error {
@@ -884,7 +891,7 @@ function fail(code, message) {
 }
 function contained(root, candidate) {
   const path = relative(root, candidate);
-  return path === "" || !isAbsolute2(path) && path !== ".." && !path.startsWith(`..${sep}`);
+  return path === "" || !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
 }
 function sessionRootIdentity(root, info) {
   return `${root}\0${info.dev}\0${info.ino}`;
@@ -933,14 +940,14 @@ var SessionDirectoryLister = class {
     checkDeadline();
     if (metadata === void 0) fail("SESSION_NOT_FOUND", "The session is unavailable");
     const workingDirectory = metadata.workingDirectory;
-    if (!workingDirectory || !isAbsolute2(workingDirectory)) {
+    if (!workingDirectory || !isAbsolute(workingDirectory)) {
       fail("SESSION_ROOT_UNAVAILABLE", "The session working directory is unavailable");
     }
     let root;
     let rootIdentity;
     try {
       root = await realpath(workingDirectory);
-      const info = await stat2(root, { bigint: true });
+      const info = await stat(root, { bigint: true });
       if (!info.isDirectory()) fail("SESSION_ROOT_UNAVAILABLE", "The session working directory is unavailable");
       rootIdentity = sessionRootIdentity(root, info);
     } catch (error) {
@@ -953,7 +960,7 @@ var SessionDirectoryLister = class {
     checkDeadline();
     let target = root;
     for (const segment of path === "" ? [] : path.split("/")) {
-      target = join3(target, segment);
+      target = join2(target, segment);
       const info = await lstat(target);
       checkDeadline();
       if (info.isSymbolicLink()) fail("DIRECTORY_BLOCKED", "Links cannot be opened");
@@ -978,7 +985,7 @@ var SessionDirectoryLister = class {
         }
         let kind = "blocked";
         if (isSafeSessionDirectoryPath(entry.name) && !entry.name.includes("/")) {
-          const child = join3(target, entry.name);
+          const child = join2(target, entry.name);
           const info = await lstat(child);
           checkDeadline();
           if (!info.isSymbolicLink() && contained(root, await realpath(child))) {
@@ -994,7 +1001,7 @@ var SessionDirectoryLister = class {
       }
       const latestMetadata = await this.metadata(sessionId);
       const latestRoot = await realpath(workingDirectory);
-      const latestInfo = await stat2(latestRoot, { bigint: true });
+      const latestInfo = await stat(latestRoot, { bigint: true });
       if (latestMetadata?.workingDirectory !== workingDirectory || sessionRootIdentity(latestRoot, latestInfo) !== rootIdentity || await realpath(target) !== canonicalTarget) {
         fail("SESSION_ROOT_CHANGED", "The session directory changed");
       }
@@ -1012,13 +1019,15 @@ var SessionDirectoryLister = class {
 };
 
 // src/session-file.ts
+import { isUtf8 } from "node:buffer";
 import { createHash as createHash3 } from "node:crypto";
-import { constants as constants2 } from "node:fs";
-import { lstat as lstat2, open, realpath as realpath2, stat as stat3 } from "node:fs/promises";
-import { basename, extname, isAbsolute as isAbsolute3, join as join4 } from "node:path";
+import { constants } from "node:fs";
+import { lstat as lstat2, open, realpath as realpath2, stat as stat2 } from "node:fs/promises";
+import { extname, isAbsolute as isAbsolute2, join as join3 } from "node:path";
 import { promisify } from "node:util";
 import { gzip } from "node:zlib";
 import sharp from "sharp";
+import { fileTypeFromBuffer } from "file-type";
 
 // src/session-video.ts
 function requireVideo(valid) {
@@ -1181,105 +1190,8 @@ function fail2(code) {
 function fileIdentity(info, includeChangeTime = true) {
   return `${info.dev}\0${info.ino}\0${info.size}\0${info.mtimeNs}\0${includeChangeTime ? info.ctimeNs : ""}\0${info.mode}\0${info.nlink}`;
 }
-var textExtensions = /* @__PURE__ */ new Set([
-  ".txt",
-  ".log",
-  ".csv",
-  ".tsv",
-  ".md",
-  ".mdx",
-  ".markdown",
-  ".rst",
-  ".json",
-  ".jsonc",
-  ".jsonl",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".ini",
-  ".cfg",
-  ".conf",
-  ".xml",
-  ".html",
-  ".htm",
-  ".css",
-  ".scss",
-  ".sass",
-  ".less",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".ts",
-  ".tsx",
-  ".kt",
-  ".kts",
-  ".java",
-  ".py",
-  ".pyi",
-  ".go",
-  ".rs",
-  ".c",
-  ".h",
-  ".cpp",
-  ".hpp",
-  ".cc",
-  ".cs",
-  ".fs",
-  ".swift",
-  ".m",
-  ".mm",
-  ".rb",
-  ".php",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".fish",
-  ".ps1",
-  ".psm1",
-  ".bat",
-  ".cmd",
-  ".sql",
-  ".r",
-  ".dart",
-  ".vue",
-  ".svelte",
-  ".lua",
-  ".gradle",
-  ".properties",
-  ".gitignore",
-  ".gitattributes",
-  ".editorconfig",
-  ".env",
-  ".dockerignore",
-  ".graphql",
-  ".gql",
-  ".proto",
-  ".cmake",
-  ".diff",
-  ".patch"
-]);
-var textNames = /* @__PURE__ */ new Set([
-  "readme",
-  "license",
-  "licence",
-  "notice",
-  "changelog",
-  "authors",
-  "dockerfile",
-  "containerfile",
-  "makefile",
-  "gemfile",
-  "rakefile",
-  ".gitignore",
-  ".gitattributes",
-  ".editorconfig",
-  ".env",
-  ".dockerignore"
-]);
 function textMediaType(path) {
   const extension = extname(path).toLowerCase();
-  if (!textExtensions.has(extension) && !textNames.has(basename(path).toLowerCase())) fail2("FILE_UNSUPPORTED");
   switch (extension) {
     case ".html":
     case ".htm":
@@ -1304,6 +1216,9 @@ function textMediaType(path) {
       return "text/plain";
   }
 }
+function isPreviewableText(bytes) {
+  return isUtf8(bytes) && !bytes.some((byte) => byte <= 8 || byte === 11 || byte >= 14 && byte <= 31 || byte === 127);
+}
 function rejectAnimatedPng(bytes) {
   for (let offset = 8; offset + 12 <= bytes.length; ) {
     const size = bytes.readUInt32BE(offset);
@@ -1407,13 +1322,19 @@ var SessionFileReader = class {
     if (!SessionFileReadDataSchema.safeParse({ path, rootRevision }).success) fail2("INVALID_FILE_PATH");
     const schema = version === SESSION_FILE_READ_V2_VERSION ? SessionFileReadV2ResultDataSchema : SessionFileReadResultDataSchema;
     return schema.parse(await this.#run(
-      (checkDeadline) => this.#read(sessionId, path, rootRevision, checkDeadline, false, version)
+      (checkDeadline) => this.#read(sessionId, path, rootRevision, checkDeadline, "preview", version)
     ));
   }
   async readResource(sessionId, path, rootRevision) {
     if (!SessionResourceReadDataSchema.safeParse({ path, rootRevision }).success) fail2("INVALID_FILE_PATH");
     return SessionResourceReadResultDataSchema.parse(await this.#run(
-      (checkDeadline) => this.#read(sessionId, path, rootRevision, checkDeadline, true)
+      (checkDeadline) => this.#read(sessionId, path, rootRevision, checkDeadline, "resource")
+    ));
+  }
+  async download(sessionId, path, rootRevision) {
+    if (!SessionFileDownloadDataSchema.safeParse({ path, rootRevision }).success) fail2("INVALID_FILE_PATH");
+    return SessionFileDownloadResultDataSchema.parse(await this.#run(
+      (checkDeadline) => this.#read(sessionId, path, rootRevision, checkDeadline, "download")
     ));
   }
   async #run(read) {
@@ -1441,18 +1362,20 @@ var SessionFileReader = class {
       clearTimeout(timer);
     }
   }
-  async #read(sessionId, path, rootRevision, checkDeadline, resource, version = SESSION_FILE_READ_VERSION) {
+  async #read(sessionId, path, rootRevision, checkDeadline, mode, version = SESSION_FILE_READ_VERSION) {
+    const resource = mode === "resource";
+    const download = mode === "download";
     const metadata = await this.metadata(sessionId);
     checkDeadline();
     if (metadata === void 0) fail2("SESSION_NOT_FOUND");
     const workingDirectory = metadata.workingDirectory;
-    if (!workingDirectory || !isAbsolute3(workingDirectory)) fail2("SESSION_ROOT_UNAVAILABLE");
+    if (!workingDirectory || !isAbsolute2(workingDirectory)) fail2("SESSION_ROOT_UNAVAILABLE");
     let root;
     let rootIdentity;
     try {
       if ((await lstat2(workingDirectory)).isSymbolicLink()) fail2("FILE_UNAVAILABLE");
       root = await realpath2(workingDirectory);
-      const info = await stat3(root, { bigint: true });
+      const info = await stat2(root, { bigint: true });
       if (!info.isDirectory()) fail2("SESSION_ROOT_UNAVAILABLE");
       rootIdentity = sessionRootIdentity(root, info);
     } catch (error) {
@@ -1461,13 +1384,13 @@ var SessionFileReader = class {
     }
     if (createHash3("sha256").update(rootIdentity).digest("base64url") !== rootRevision) fail2("SESSION_ROOT_CHANGED");
     checkDeadline();
-    const target = join4(root, ...path.split("/"));
+    const target = join3(root, ...path.split("/"));
     const inspectPath = async () => {
       let current = root;
       const segments = path.split("/");
       let file;
       for (const [index, segment] of segments.entries()) {
-        current = join4(current, segment);
+        current = join3(current, segment);
         const info = await lstat2(current, { bigint: true });
         checkDeadline();
         if (info.isSymbolicLink() || (index === segments.length - 1 ? !info.isFile() : !info.isDirectory())) {
@@ -1483,13 +1406,11 @@ var SessionFileReader = class {
       return file;
     };
     const before = await inspectPath();
-    const maxOriginalBytes = resource ? SESSION_RESOURCE_MAX_ORIGINAL_BYTES : version === SESSION_FILE_READ_V2_VERSION ? SESSION_FILE_V2_MAX_ORIGINAL_BYTES : SESSION_FILE_MAX_ORIGINAL_BYTES;
+    const maxOriginalBytes = download ? SESSION_FILE_DOWNLOAD_MAX_ORIGINAL_BYTES : resource ? SESSION_RESOURCE_MAX_ORIGINAL_BYTES : version === SESSION_FILE_READ_V2_VERSION ? SESSION_FILE_V2_MAX_ORIGINAL_BYTES : SESSION_FILE_MAX_ORIGINAL_BYTES;
     if (before.size > BigInt(maxOriginalBytes)) fail2("FILE_TOO_LARGE");
     const extension = extname(path).toLowerCase();
-    const image = [".png", ".jpg", ".jpeg", ".webp"].includes(extension);
-    const video = !resource && version === SESSION_FILE_READ_V2_VERSION && [".mp4", ".webm"].includes(extension);
-    const mediaType = resource ? resourceMediaType(extension) : image ? "image/webp" : video ? extension === ".mp4" ? "video/mp4" : "video/webm" : textMediaType(path);
-    const handle = await open(target, constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0) | (constants2.O_NONBLOCK ?? 0));
+    const resourceType = resource ? resourceMediaType(extension) : void 0;
+    const handle = await open(target, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
     try {
       const opened = await handle.stat({ bigint: true });
       const includeChangeTime = process.platform !== "win32";
@@ -1509,27 +1430,43 @@ var SessionFileReader = class {
       };
       const bytes = await readOriginal();
       let canonical;
-      if (image) {
-        if (resource) {
+      let mediaType;
+      if (download) {
+        mediaType = "application/octet-stream";
+        canonical = bytes;
+      } else if (resourceType !== void 0) {
+        mediaType = resourceType;
+        if (resourceType.startsWith("image/")) {
           await validateRawImage(bytes, extension, checkDeadline);
-          canonical = bytes;
-        } else canonical = await imagePreview(bytes, extension, checkDeadline);
-      } else if (mediaType === "video/mp4" || mediaType === "video/webm") {
-        try {
-          validateSessionVideo(bytes, mediaType);
-        } catch (error) {
-          throw new SessionFileReadError("FILE_UNSUPPORTED", { cause: error });
-        }
+        } else if (!isPreviewableText(bytes)) fail2("FILE_UNSUPPORTED");
+        canonical = bytes;
+      } else if (isPreviewableText(bytes)) {
+        mediaType = textMediaType(path);
         canonical = bytes;
       } else {
-        let text;
+        let detected;
         try {
-          text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+          detected = await fileTypeFromBuffer(bytes, {
+            maxBufferSize: maxOriginalBytes,
+            signal: AbortSignal.timeout(SESSION_FILE_TIMEOUT_MS)
+          });
         } catch (error) {
           throw new SessionFileReadError("FILE_UNSUPPORTED", { cause: error });
         }
-        if (/[\u0000-\u0008\u000b\u000e-\u001f\u007f]/u.test(text)) fail2("FILE_UNSUPPORTED");
-        canonical = bytes;
+        checkDeadline();
+        if (detected?.mime === "image/png" || detected?.mime === "image/jpeg" || detected?.mime === "image/webp") {
+          mediaType = "image/webp";
+          canonical = await imagePreview(bytes, `.${detected.ext}`, checkDeadline);
+        } else if (detected?.mime === "video/mp4" || detected?.mime === "video/webm") {
+          if (version !== SESSION_FILE_READ_V2_VERSION || extension !== (detected.mime === "video/mp4" ? ".mp4" : ".webm")) fail2("FILE_UNSUPPORTED");
+          mediaType = detected.mime;
+          try {
+            validateSessionVideo(bytes, mediaType);
+          } catch (error) {
+            throw new SessionFileReadError("FILE_UNSUPPORTED", { cause: error });
+          }
+          canonical = bytes;
+        } else fail2("FILE_UNSUPPORTED");
       }
       const threshold = resource ? SESSION_RESOURCE_GZIP_THRESHOLD_BYTES : SESSION_FILE_GZIP_THRESHOLD_BYTES;
       const encoding = originalByteLength >= threshold ? "gzip" : "identity";
@@ -1538,7 +1475,7 @@ var SessionFileReader = class {
       checkDeadline();
       try {
         const latestRoot = await realpath2(workingDirectory);
-        const latestRootInfo = await stat3(latestRoot, { bigint: true });
+        const latestRootInfo = await stat2(latestRoot, { bigint: true });
         if (latestMetadata?.workingDirectory !== workingDirectory || (await lstat2(workingDirectory)).isSymbolicLink() || sessionRootIdentity(latestRoot, latestRootInfo) !== rootIdentity) fail2("SESSION_ROOT_CHANGED");
       } catch (error) {
         if (error instanceof SessionFileReadError) throw error;
@@ -1553,7 +1490,7 @@ var SessionFileReader = class {
         throw new SessionFileReadError("FILE_CHANGED", { cause: error });
       }
       checkDeadline();
-      return (resource ? SessionResourceReadResultDataSchema : version === SESSION_FILE_READ_V2_VERSION ? SessionFileReadV2ResultDataSchema : SessionFileReadResultDataSchema).parse({
+      return (download ? SessionFileDownloadResultDataSchema : resource ? SessionResourceReadResultDataSchema : version === SESSION_FILE_READ_V2_VERSION ? SessionFileReadV2ResultDataSchema : SessionFileReadResultDataSchema).parse({
         path,
         rootRevision,
         mediaType,
@@ -1902,6 +1839,9 @@ function createWorkbenchOperations(options) {
   return routes;
 }
 
+// src/legacy-client-state.ts
+var LEGACY_CLIENT_STATE_DIRECTORY = Buffer.from("2e626c7565706177", "hex").toString("utf8");
+
 // src/research-tools.ts
 var RESEARCH_TOOL_NAMES = ["research_list", "research_read", "research_search"];
 var RESEARCH_SEARCH_FILES = 64;
@@ -1919,11 +1859,11 @@ var ResearchError = class extends Error {
   code;
 };
 async function researchRoot(workingDirectory) {
-  if (!isAbsolute4(workingDirectory)) throw new ResearchError("SESSION_ROOT_UNAVAILABLE");
+  if (!isAbsolute3(workingDirectory)) throw new ResearchError("SESSION_ROOT_UNAVAILABLE");
   try {
     if ((await lstat3(workingDirectory)).isSymbolicLink()) throw new ResearchError("SESSION_ROOT_UNAVAILABLE");
     const root = await realpath3(workingDirectory);
-    const info = await stat4(root, { bigint: true });
+    const info = await stat3(root, { bigint: true });
     if (!info.isDirectory()) throw new ResearchError("SESSION_ROOT_UNAVAILABLE");
     return {
       workingDirectory: root,
@@ -1948,7 +1888,7 @@ var privateNames = /* @__PURE__ */ new Set([
   ".docker",
   ".copilot",
   ".ak",
-  ".bluepaw",
+  LEGACY_CLIENT_STATE_DIRECTORY,
   ".copilot-remote",
   ".agentknight",
   "session-state",
@@ -2041,7 +1981,7 @@ var ResearchTools = class {
   }
   async #validate(path) {
     const source = await this.#source();
-    const target = join5(this.root.workingDirectory, ...path.split("/"));
+    const target = join4(this.root.workingDirectory, ...path.split("/"));
     if (sensitiveSegments(this.root.workingDirectory.split(/[\\/]/u)) || !allowedPath(path, source.excludedPaths ?? []) || this.privateDirectories.some((directory) => contained(directory, target))) {
       throw new ResearchError("RESEARCH_PATH_BLOCKED", "The requested path is excluded from research");
     }
@@ -2086,7 +2026,7 @@ var ResearchTools = class {
     const source = await this.#source();
     return result.entries.filter((entry) => {
       const child = path ? `${path}/${entry.name}` : entry.name;
-      return entry.kind !== "blocked" && allowedPath(child, source.excludedPaths ?? []) && !this.privateDirectories.some((directory) => contained(directory, join5(this.root.workingDirectory, ...child.split("/"))));
+      return entry.kind !== "blocked" && allowedPath(child, source.excludedPaths ?? []) && !this.privateDirectories.some((directory) => contained(directory, join4(this.root.workingDirectory, ...child.split("/"))));
     });
   }
   async list(input) {
@@ -2186,7 +2126,7 @@ var ResearchTools = class {
         if (path === void 0) break;
         inspected++;
         await this.#validate(path);
-        const target = join5(this.root.workingDirectory, ...path.split("/"));
+        const target = join4(this.root.workingDirectory, ...path.split("/"));
         const info = await lstat3(target);
         if (info.isSymbolicLink()) {
           skippedFiles++;
@@ -2307,9 +2247,9 @@ function researchAwareCodingAgentAdapter(inner, research) {
     if (!research.store.has(id)) return false;
     if (inner.isSessionVisible?.(parent) !== false) return true;
     try {
-      const access2 = inner.captureResearchAccess?.(parent);
-      access2?.assertCurrent();
-      return access2?.detached === true;
+      const access = inner.captureResearchAccess?.(parent);
+      access?.assertCurrent();
+      return access?.detached === true;
     } catch {
       return false;
     }
@@ -2461,7 +2401,7 @@ function createRelaySocket(uri, options) {
 // src/service/requests/session-communication.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash as createHash8 } from "node:crypto";
-import { join as join7 } from "node:path";
+import { join as join6 } from "node:path";
 import { performance as performance2 } from "node:perf_hooks";
 
 // src/repeated-error-diagnostics.ts
@@ -2729,14 +2669,14 @@ var SessionPublicationScope = class {
 
 // src/service/requests/communication-operations.ts
 import { promisify as promisify2 } from "node:util";
-import { constants as constants4, gzip as gzip3 } from "node:zlib";
+import { constants as constants3, gzip as gzip3 } from "node:zlib";
 
 // src/session-git-diff.ts
 import { execFile } from "node:child_process";
 import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
-import { constants as constants3 } from "node:fs";
-import { chmod, lstat as lstat4, mkdir as mkdir2, open as open2, readlink, realpath as realpath4, rm, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname, isAbsolute as isAbsolute5, join as join6, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { constants as constants2 } from "node:fs";
+import { chmod, lstat as lstat4, mkdir as mkdir2, open as open2, readlink, realpath as realpath4, rm, stat as stat4, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname, isAbsolute as isAbsolute4, join as join5, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
 var SESSION_GIT_DIFF_CONCURRENCY = 4;
 var SESSION_GIT_DIFF_TIMEOUT_MS = 15e3;
 var SESSION_GIT_DIFF_MAX_SOURCE_BYTES = 8 * 1024 * 1024;
@@ -2752,6 +2692,28 @@ var SessionGitDiffError = class extends Error {
 function fail3(code, message) {
   throw new SessionGitDiffError(code, message);
 }
+function fileError(error) {
+  if (error instanceof SessionGitDiffError && error.code === "DIFF_BLOCKED") {
+    return { code: "DIFF_BLOCKED", message: error.message };
+  }
+  if (error instanceof Error && "code" in error && typeof error.code === "string" && ["EACCES", "EPERM", "EBUSY", "ENAMETOOLONG", "EINVAL", "EIO", "ELOOP"].includes(error.code)) {
+    return { code: "DIFF_FILE_UNAVAILABLE", message: `Cannot read this path (${error.code})` };
+  }
+  return void 0;
+}
+async function forFile(path, work, operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    const failure = work.partial ? fileError(error) : void 0;
+    if (failure === void 0) throw error;
+    throw new SessionGitDiffError(
+      failure.code === "DIFF_BLOCKED" ? "DIFF_FILE_BLOCKED" : failure.code,
+      `${path}: ${failure.message}`,
+      { cause: error }
+    );
+  }
+}
 function changed() {
   return fail3("DIFF_CHANGED", "The project diff changed; refresh the changed-file list");
 }
@@ -2787,12 +2749,30 @@ function environment() {
 function isExit(error, code) {
   return error instanceof Error && "code" in error && error.code === code && "stdout" in error && Buffer.isBuffer(error.stdout) && "stderr" in error && Buffer.isBuffer(error.stderr);
 }
+function hashFileError(error, path) {
+  if (!isExit(error, 128)) return void 0;
+  const diagnostic = decode(error.stderr).trim().split(/\r?\n/u).at(-1) ?? "";
+  if (!diagnostic.startsWith(`fatal: could not open '${path}' for reading: `)) return void 0;
+  return { code: "DIFF_FILE_UNAVAILABLE", message: "Cannot normalize this path for comparison" };
+}
 var Work = class {
+  constructor(partial) {
+    this.partial = partial;
+  }
+  partial;
   deadline = Date.now() + SESSION_GIT_DIFF_TIMEOUT_MS;
   env = environment();
   bytes = 0;
+  linkFiles = /* @__PURE__ */ new Set();
+  symlinks = true;
   #filterConfig = [];
   async disableExternalFilters(repository) {
+    this.symlinks = decode(await this.git(repository, [
+      "config",
+      "--type=bool",
+      "--get",
+      "core.symlinks"
+    ], { allowExitOne: true })).trim() !== "false";
     const names = records(await this.git(repository, [
       "config",
       "--includes",
@@ -2842,10 +2822,10 @@ var Work = class {
             ...this.env,
             ...options.objectDirectory === void 0 ? {} : { GIT_OBJECT_DIRECTORY: options.objectDirectory },
             ...options.isolated ? {
-              GIT_DIR: join6(cwd, "no-repository"),
+              GIT_DIR: join5(cwd, "no-repository"),
               GIT_CONFIG_NOSYSTEM: "1",
               GIT_ATTR_NOSYSTEM: "1",
-              GIT_CONFIG_GLOBAL: join6(cwd, "gitconfig")
+              GIT_CONFIG_GLOBAL: join5(cwd, "gitconfig")
             } : {}
           }
         }, (error, output2, stderr) => {
@@ -2873,7 +2853,7 @@ async function inspect(root, path, work, kind = "file") {
   let current = root;
   const segments = path.split("/");
   for (const [index, segment] of segments.entries()) {
-    current = join6(current, segment);
+    current = join5(current, segment);
     let info;
     try {
       info = await lstat4(current, { bigint: true });
@@ -2898,13 +2878,27 @@ async function inspect(root, path, work, kind = "file") {
   return void 0;
 }
 async function readCurrent(root, path, algorithm, work, keepBytes = false) {
-  const before = await inspect(root, path, work);
+  const kind = work.partial ? "link" : "file";
+  const before = await inspect(root, path, work, kind);
   if (before === void 0) return void 0;
+  if (before.isSymbolicLink()) {
+    const bytes = Buffer.from(await readlink(join5(root, ...path.split("/"))), "utf8");
+    const latest = await inspect(root, path, work, "link");
+    if (latest === void 0 || identity(latest) !== identity(before)) changed();
+    const oid = createHash5(algorithm).update(`blob ${bytes.length}\0`).update(bytes).digest("hex");
+    return {
+      oid,
+      rawOid: oid,
+      identity: identity(before),
+      mode: "120000",
+      ...keepBytes ? { bytes } : {}
+    };
+  }
   if (before.size > BigInt(MAX_SCAN_BYTES - work.bytes) || keepBytes && before.size > BigInt(SESSION_GIT_DIFF_MAX_SOURCE_BYTES)) limit();
   work.bytes += Number(before.size);
   const handle = await open2(
-    join6(root, ...path.split("/")),
-    constants3.O_RDONLY | (constants3.O_NOFOLLOW ?? 0) | (constants3.O_NONBLOCK ?? 0)
+    join5(root, ...path.split("/")),
+    constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0) | (constants2.O_NONBLOCK ?? 0)
   );
   try {
     const opened = await handle.stat({ bigint: true });
@@ -2929,7 +2923,7 @@ async function readCurrent(root, path, algorithm, work, keepBytes = false) {
       oid: rawOid,
       rawOid,
       identity: identity(before),
-      mode: process.platform !== "win32" && (before.mode & 0o111n) !== 0n ? "100755" : "100644",
+      mode: work.linkFiles.has(path) ? "120000" : process.platform !== "win32" && (before.mode & 0o111n) !== 0n ? "100755" : "100644",
       ...keepBytes ? { bytes: Buffer.concat(chunks) } : {}
     };
   } finally {
@@ -2965,7 +2959,6 @@ function scopedPath(context, path) {
   const prefix = context.prefix === "" ? "" : `${context.prefix}/`;
   if (!path.startsWith(prefix)) fail3("DIFF_BLOCKED", "Git returned a path outside the session");
   const scoped = path.slice(prefix.length);
-  if (!safePath(scoped)) fail3("DIFF_BLOCKED", "The project contains an unsupported path");
   return scoped;
 }
 function records(output2) {
@@ -2996,7 +2989,7 @@ async function changes(context, work) {
     return scoped2;
   };
   for (const record of tree) {
-    const match = /^(\d{6}) (blob|commit) ([a-f0-9]{40}|[a-f0-9]{64})\t(.+)$/u.exec(record);
+    const match = /^(\d{6}) (blob|commit) ([a-f0-9]{40}|[a-f0-9]{64})\t([\s\S]+)$/u.exec(record);
     if (!match?.[1] || !match[3] || !match[4]) fail3("DIFF_UNAVAILABLE", "Git returned an invalid tree");
     blobs.set(scoped(match[4]), { mode: match[1], oid: match[3] });
   }
@@ -3008,7 +3001,7 @@ async function changes(context, work) {
     "--",
     ...paths
   ]))) {
-    const match = /^(\d{6}) ([a-f0-9]{40}|[a-f0-9]{64}) [0-3]\t(.+)$/u.exec(record);
+    const match = /^(\d{6}) ([a-f0-9]{40}|[a-f0-9]{64}) [0-3]\t([\s\S]+)$/u.exec(record);
     if (!match?.[1] || !match[2] || !match[3]) fail3("DIFF_UNAVAILABLE", "Git returned an invalid index");
     tracked.set(scoped(match[3]), { mode: match[1], oid: match[2] });
   }
@@ -3047,38 +3040,88 @@ async function changes(context, work) {
     files: untracked
   }), "utf8") > SESSION_GIT_DIFF_MAX_RESPONSE_BYTES) limit();
   const result = [];
+  const errors = /* @__PURE__ */ new Map();
   const algorithm = context.baseCommit.length === 64 ? "sha256" : "sha1";
   const currentFiles = /* @__PURE__ */ new Map();
+  if (work.partial && !work.symlinks) {
+    for (const [path, blob] of tracked) if (blob.mode === "120000") work.linkFiles.add(path);
+  }
   for (const path of [...candidates].sort()) {
     work.check();
-    const original = blobs.get(path);
-    const indexed = tracked.get(path);
-    if ([original?.mode, indexed?.mode].some((mode) => mode !== void 0 && mode !== "100644" && mode !== "100755")) {
-      await unchangedSpecial(context, path, original, indexed, work);
-      candidates.delete(path);
-      continue;
+    try {
+      if (!safePath(path)) fail3("DIFF_BLOCKED", "This path cannot be safely accessed on the PC");
+      const original = blobs.get(path);
+      const indexed = tracked.get(path);
+      if ([original?.mode, indexed?.mode].some((mode) => mode !== void 0 && mode !== "100644" && mode !== "100755" && !(work.partial && mode === "120000"))) {
+        await unchangedSpecial(context, path, original, indexed, work);
+        candidates.delete(path);
+        continue;
+      }
+      const current = await readCurrent(context.root, path, algorithm, work);
+      if (current !== void 0) currentFiles.set(path, current);
+    } catch (error) {
+      const failure = fileError(error);
+      if (failure === void 0) throw error;
+      errors.set(path, failure);
     }
-    const current = await readCurrent(context.root, path, algorithm, work);
-    if (current !== void 0) currentFiles.set(path, current);
   }
-  if (currentFiles.size > 0) {
-    const hashes = decode(await work.git(context.repository, ["hash-object", "--stdin-paths"], {
-      input: [...currentFiles.keys()].map((path) => [context.prefix, path].filter(Boolean).join("/")).join("\n") + "\n"
-    })).trim().split("\n");
-    if (hashes.length !== currentFiles.size) changed();
-    for (const [index, [path, current]] of [...currentFiles].entries()) {
-      const oid = hashes[index];
-      if (!oid || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(oid)) changed();
-      const latest = await inspect(context.root, path, work);
-      if (latest === void 0 || identity(latest) !== current.identity) changed();
-      current.oid = oid;
+  const regularFiles = [...currentFiles].filter(([, current]) => current.mode !== "120000");
+  if (regularFiles.length > 0) {
+    let hashes;
+    try {
+      hashes = decode(await work.git(context.repository, ["hash-object", "--stdin-paths"], {
+        input: regularFiles.map(([path]) => JSON.stringify([context.prefix, path].filter(Boolean).join("/"))).join("\n") + "\n"
+      })).trim().split("\n");
+    } catch (error) {
+      if (!work.partial || !isExit(error, 128) || regularFiles.length > SESSION_GIT_DIFF_MAX_FILES) throw error;
+      hashes = [];
+      for (const [path] of regularFiles) {
+        const repositoryPath = [context.prefix, path].filter(Boolean).join("/");
+        try {
+          hashes.push(decode(await work.git(context.repository, ["hash-object", "--stdin-paths"], {
+            input: JSON.stringify(repositoryPath) + "\n"
+          })).trim());
+        } catch (error2) {
+          const failure = hashFileError(error2, repositoryPath);
+          if (failure === void 0) throw error2;
+          errors.set(path, failure);
+          currentFiles.delete(path);
+          hashes.push("");
+        }
+      }
+    }
+    if (hashes.length !== regularFiles.length) changed();
+    for (const [index, [path, current]] of regularFiles.entries()) {
+      if (errors.has(path)) continue;
+      try {
+        const oid = hashes[index];
+        if (!oid || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(oid)) changed();
+        const latest = await inspect(context.root, path, work);
+        if (latest === void 0 || identity(latest) !== current.identity) changed();
+        current.oid = oid;
+      } catch (error) {
+        const failure = work.partial ? fileError(error) : void 0;
+        if (failure === void 0) throw error;
+        errors.set(path, failure);
+        currentFiles.delete(path);
+      }
     }
   }
   for (const path of [...candidates].sort()) {
     const original = blobs.get(path);
     const current = currentFiles.get(path);
+    const error = errors.get(path);
+    if (error !== void 0) {
+      result.push({
+        entry: { path, status: original === void 0 ? tracked.has(path) ? "added" : "untracked" : tracked.has(path) ? "modified" : "deleted", error },
+        base: original,
+        current: void 0
+      });
+      if (result.length > SESSION_GIT_DIFF_MAX_FILES) limit();
+      continue;
+    }
     if (original === void 0 && current === void 0) continue;
-    if (original?.oid === current?.oid && (process.platform === "win32" || original?.mode === current?.mode)) continue;
+    if (original?.oid === current?.oid && original?.mode === "120000" === (current?.mode === "120000") && (process.platform === "win32" || original?.mode === current?.mode)) continue;
     result.push({
       entry: { path, status: original === void 0 ? tracked.has(path) ? "added" : "untracked" : current === void 0 ? "deleted" : "modified" },
       base: original,
@@ -3093,9 +3136,9 @@ async function unchangedSpecial(context, path, original, indexed, work) {
   if (original === void 0 || indexed?.mode !== original.mode || indexed.oid !== original.oid) return blocked();
   if (original.mode === "160000") {
     if (await inspect(context.root, path, work, "directory") === void 0) blocked();
-    const target = join6(context.root, ...path.split("/"));
+    const target = join5(context.root, ...path.split("/"));
     try {
-      await lstat4(join6(target, ".git"));
+      await lstat4(join5(target, ".git"));
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
       throw error;
@@ -3107,7 +3150,7 @@ async function unchangedSpecial(context, path, original, indexed, work) {
     const algorithm = context.baseCommit.length === 64 ? "sha256" : "sha1";
     let oid;
     if (info.isSymbolicLink()) {
-      const target = Buffer.from(await readlink(join6(context.root, ...path.split("/"))), "utf8");
+      const target = Buffer.from(await readlink(join5(context.root, ...path.split("/"))), "utf8");
       oid = createHash5(algorithm).update(`blob ${target.length}\0`).update(target).digest("hex");
     } else {
       oid = (await readCurrent(context.root, path, algorithm, work))?.rawOid;
@@ -3130,7 +3173,20 @@ async function patch(context, change, work, scratchDirectory) {
   if (current?.rawOid !== change.current?.rawOid || current?.mode !== change.current?.mode) changed();
   let original = Buffer.alloc(0);
   if (change.base !== void 0) {
-    const size = Number(decode(await work.git(context.repository, ["cat-file", "-s", change.base.oid])).trim());
+    let sizeBytes;
+    try {
+      sizeBytes = await work.git(context.repository, ["cat-file", "-s", change.base.oid]);
+    } catch (error) {
+      if (work.partial && isExit(error, 128) && decode(error.stderr).trim() === "fatal: git cat-file: could not get object info") {
+        throw new SessionGitDiffError(
+          "DIFF_FILE_UNAVAILABLE",
+          `${change.entry.path}: The base version of this file is unavailable`,
+          { cause: error }
+        );
+      }
+      throw error;
+    }
+    const size = Number(decode(sizeBytes).trim());
     if (!Number.isSafeInteger(size) || size < 0 || size > SESSION_GIT_DIFF_MAX_SOURCE_BYTES) limit();
     original = await work.git(context.repository, ["cat-file", "blob", change.base.oid], { maxBuffer: size + 1 });
     if (original.length !== size) changed();
@@ -3143,13 +3199,13 @@ async function patch(context, change, work, scratchDirectory) {
   if ((await lstat4(directory)).isSymbolicLink() || !samePath(await realpath4(directory), directory)) {
     fail3("DIFF_UNAVAILABLE", "Project diff storage cannot use links");
   }
-  const scratch = join6(directory, randomUUID3());
+  const scratch = join5(directory, randomUUID3());
   await mkdir2(scratch, { mode: 448 });
   let text;
   try {
     let bytes = current?.bytes ?? Buffer.alloc(0);
-    if (current !== void 0) {
-      const objectDirectory = join6(scratch, "objects");
+    if (current !== void 0 && current.mode !== "120000") {
+      const objectDirectory = join5(scratch, "objects");
       await mkdir2(objectDirectory);
       const path = [context.prefix, change.entry.path].filter(Boolean).join("/");
       const oid = decode(await work.git(context.repository, ["hash-object", "-w", "--stdin", `--path=${path}`], {
@@ -3163,18 +3219,18 @@ async function patch(context, change, work, scratchDirectory) {
       });
     }
     if (binary(original) || binary(bytes)) return { patch: "", binary: true };
-    for (const side of ["a", "b"]) await mkdir2(join6(scratch, side));
+    for (const side of ["a", "b"]) await mkdir2(join5(scratch, side));
     for (const [side, content, mode] of [
       ["a", original, change.base?.mode],
       ["b", bytes, current?.mode]
     ]) {
       if (mode === void 0) continue;
-      const file = join6(scratch, side, ...change.entry.path.split("/"));
+      const file = join5(scratch, side, ...change.entry.path.split("/"));
       await mkdir2(dirname(file), { recursive: true });
       await writeFile2(file, content, { flag: "wx", mode: 384 });
       if (process.platform !== "win32") await chmod(file, mode === "100755" ? 448 : 384);
     }
-    await writeFile2(join6(scratch, "gitconfig"), "", { flag: "wx", mode: 384 });
+    await writeFile2(join5(scratch, "gitconfig"), "", { flag: "wx", mode: 384 });
     text = decode(await work.git(scratch, [
       "-c",
       "core.quotePath=false",
@@ -3196,6 +3252,18 @@ async function patch(context, change, work, scratchDirectory) {
   } finally {
     await rm(scratch, { recursive: true, force: true, maxRetries: 3 });
   }
+  if (current?.mode === "120000" || change.base?.mode === "120000") {
+    text = text.replace(/^new file mode \d+$/mu, `new file mode ${current?.mode}`).replace(/^deleted file mode \d+$/mu, `deleted file mode ${change.base?.mode}`);
+    if (current !== void 0 && change.base !== void 0 && current.mode !== change.base.mode) {
+      text = text.replace(/^old mode \d+\nnew mode \d+\n/mu, "");
+      if (text === "") text = `diff --git a/${change.entry.path} b/${change.entry.path}
+`;
+      const end = text.indexOf("\n") + 1;
+      text = `${text.slice(0, end)}old mode ${change.base.mode}
+new mode ${current.mode}
+${text.slice(end)}`;
+    }
+  }
   if (Buffer.byteLength(text, "utf8") > SESSION_GIT_DIFF_MAX_PATCH_BYTES) limit();
   return { patch: text, binary: false };
 }
@@ -3207,14 +3275,14 @@ var SessionGitDiffReader = class {
   metadata;
   scratchDirectory;
   #active = 0;
-  async read(sessionId, data) {
+  async read(sessionId, data, version = SESSION_GIT_DIFF_PARTIAL_VERSION) {
     if (!SessionGitDiffDataSchema.safeParse(data).success || data.path !== void 0 && !safePath(data.path)) {
       fail3("INVALID_DIFF_PATH", "The project diff request is invalid");
     }
     if (this.#active >= SESSION_GIT_DIFF_CONCURRENCY) fail3("DIFF_BUSY", "Too many project diff requests");
     this.#active++;
-    const work = new Work();
-    const pending = this.#read(sessionId, data, work).finally(() => {
+    const work = new Work(version >= SESSION_GIT_DIFF_PARTIAL_VERSION);
+    const pending = this.#read(sessionId, data, work, version).finally(() => {
       this.#active--;
     });
     let timer;
@@ -3240,7 +3308,7 @@ var SessionGitDiffReader = class {
     work.check();
     if (metadata === void 0) fail3("SESSION_NOT_FOUND", "The session is unavailable");
     const workingDirectory = metadata.workingDirectory;
-    if (!workingDirectory || !isAbsolute5(workingDirectory)) {
+    if (!workingDirectory || !isAbsolute4(workingDirectory)) {
       fail3("SESSION_ROOT_UNAVAILABLE", "The session working directory is unavailable");
     }
     let root;
@@ -3250,7 +3318,7 @@ var SessionGitDiffReader = class {
       if ((await lstat4(workingDirectory)).isSymbolicLink() || !samePath(root, resolve2(workingDirectory))) {
         fail3("DIFF_BLOCKED", "Links cannot be compared");
       }
-      const info = await stat5(root, { bigint: true });
+      const info = await stat4(root, { bigint: true });
       if (!info.isDirectory()) fail3("SESSION_ROOT_UNAVAILABLE", "The session working directory is unavailable");
       rootIdentity = sessionRootIdentity(root, info);
     } catch (error) {
@@ -3263,7 +3331,7 @@ var SessionGitDiffReader = class {
     let repository;
     try {
       const top = decode(await work.git(root, ["rev-parse", "--show-toplevel"])).replace(/\r?\n$/u, "");
-      if (!isAbsolute5(top)) fail3("DIFF_UNAVAILABLE", "Git returned an invalid repository");
+      if (!isAbsolute4(top)) fail3("DIFF_UNAVAILABLE", "Git returned an invalid repository");
       repository = await realpath4(top);
     } catch (error) {
       if (error instanceof SessionGitDiffError) throw error;
@@ -3282,12 +3350,12 @@ var SessionGitDiffReader = class {
       rootIdentity,
       workingDirectory,
       repository,
-      repositoryIdentity: sessionRootIdentity(repository, await stat5(repository, { bigint: true })),
+      repositoryIdentity: sessionRootIdentity(repository, await stat4(repository, { bigint: true })),
       prefix: relative2(repository, root).split(sep2).join("/"),
       ...await base(repository, work)
     };
   }
-  async #read(sessionId, data, work) {
+  async #read(sessionId, data, work, version) {
     const context = await this.#context(sessionId, data.rootRevision, work);
     if (data.baseCommit !== void 0 && data.baseCommit !== context.baseCommit) changed();
     await work.disableExternalFilters(context.repository);
@@ -3300,7 +3368,23 @@ var SessionGitDiffReader = class {
     } else {
       selected = files.find(({ entry }) => entry.path === data.path);
       if (selected === void 0) changed();
-      result = { ...common, path: data.path, ...await patch(context, selected, work, this.scratchDirectory) };
+      if (selected.entry.error !== void 0) {
+        const error = selected.entry.error;
+        fail3(
+          work.partial && error.code === "DIFF_BLOCKED" ? "DIFF_FILE_BLOCKED" : error.code,
+          `${data.path}: ${error.message}`
+        );
+      }
+      const change = selected;
+      result = {
+        ...common,
+        path: data.path,
+        ...await forFile(data.path, work, () => patch(context, change, work, this.scratchDirectory))
+      };
+    }
+    if (version < SESSION_GIT_DIFF_PARTIAL_VERSION) {
+      const blocked = files.find(({ entry }) => entry.error !== void 0)?.entry;
+      if (blocked?.error !== void 0) fail3(blocked.error.code, `${blocked.path}: ${blocked.error.message}`);
     }
     let latest;
     try {
@@ -3319,17 +3403,18 @@ var SessionGitDiffReader = class {
     }
     if (latest.repositoryIdentity !== context.repositoryIdentity || latest.baseRef !== context.baseRef || latest.baseCommit !== context.baseCommit) changed();
     if (selected !== void 0) {
-      const current = await readCurrent(
+      const path = selected.entry.path;
+      const current = await forFile(path, work, () => readCurrent(
         context.root,
-        selected.entry.path,
+        path,
         context.baseCommit.length === 64 ? "sha256" : "sha1",
         work
-      );
+      ));
       if (current?.rawOid !== selected.current?.rawOid || current?.mode !== selected.current?.mode) changed();
     }
     work.check();
     if (Buffer.byteLength(JSON.stringify(result), "utf8") > SESSION_GIT_DIFF_MAX_RESPONSE_BYTES) limit();
-    return SessionGitDiffResultDataSchema.parse(result);
+    return (version >= SESSION_GIT_DIFF_PARTIAL_VERSION ? SessionGitDiffPartialResultDataSchema : SessionGitDiffResultDataSchema).parse(result);
   }
 };
 
@@ -3845,22 +3930,22 @@ function createCommunicationOperations(options) {
     ],
     ...options.incrementalOperations,
     ...adapter.getSessionDirectoryMetadata === void 0 ? [] : [
-      ...[SESSION_GIT_DIFF_VERSION, SESSION_GIT_DIFF_GZIP_VERSION].map((version) => sessionCommunicationOperation({
+      ...[SESSION_GIT_DIFF_VERSION, SESSION_GIT_DIFF_GZIP_VERSION, SESSION_GIT_DIFF_PARTIAL_VERSION].map((version) => sessionCommunicationOperation({
         operation: SESSION_GIT_DIFF_OPERATION,
         version,
         schema: SessionGitDiffDataSchema,
         handle: async (data, request) => {
           const assertAccess = options.captureRequestAccess();
           assertAccess();
-          const result = await gitDiffReader.read(request.sessionId, data);
+          const result = await gitDiffReader.read(request.sessionId, data, version);
           let response = SessionCommunicationDataSchema.parse(result);
-          if (version === SESSION_GIT_DIFF_GZIP_VERSION) {
+          if (version >= SESSION_GIT_DIFF_GZIP_VERSION) {
             const bytes = Buffer.from(JSON.stringify(result), "utf8");
             if (bytes.length >= SESSION_GIT_DIFF_GZIP_MIN_BYTES) {
               response = SessionGitDiffGzipResultDataSchema.parse({
                 encoding: "gzip",
                 byteLength: bytes.length,
-                data: (await compress2(bytes, { level: constants4.Z_BEST_SPEED })).toString("base64")
+                data: (await compress2(bytes, { level: constants3.Z_BEST_SPEED })).toString("base64")
               });
             }
           }
@@ -3889,6 +3974,22 @@ function createCommunicationOperations(options) {
           message: "The file preview is unavailable"
         }
       })),
+      sessionCommunicationOperation({
+        operation: SESSION_FILE_DOWNLOAD_OPERATION,
+        version: SESSION_FILE_DOWNLOAD_VERSION,
+        schema: SessionFileDownloadDataSchema,
+        handle: async ({ path, rootRevision }, request) => {
+          const assertAccess = options.captureRequestAccess();
+          assertAccess();
+          const result = await fileReader.download(request.sessionId, path, rootRevision);
+          assertAccess();
+          return result;
+        },
+        onError: (error) => unsupportedOperation(error) ?? {
+          code: error instanceof SessionFileReadError || error instanceof SessionNotSharedError ? error.code : "FILE_UNAVAILABLE",
+          message: "The file download is unavailable"
+        }
+      }),
       sessionCommunicationOperation({
         operation: SESSION_RESOURCE_READ_OPERATION,
         version: SESSION_RESOURCE_READ_VERSION,
@@ -3935,14 +4036,14 @@ var SessionCommunicationHandler = class {
     const workbench = adapter.agentId === "copilot" || adapter.agentId === "managed" ? adapter.workbench : void 0;
     const researchWorkbench = workbench === void 0 ? void 0 : research;
     this.#operations = workbench === void 0 && researchWorkbench === void 0 ? void 0 : new SessionOperations({
-      directory: join7(config.dataDirectory, "workbench"),
+      directory: join6(config.dataDirectory, "workbench"),
       agentRunId,
       namespace: `${config.userId}\0${machineId}`,
       onError: operationError
     });
     this.#dispatcher = new SessionCommunicationDispatcher(createCommunicationOperations({
       adapter,
-      gitDiffDirectory: join7(config.dataDirectory, "git-diff"),
+      gitDiffDirectory: join6(config.dataDirectory, "git-diff"),
       publications: options.publications,
       captureRequestAccess: () => {
         const assertCurrent = this.#requestContext.getStore()?.assertRequestCurrent;
@@ -4010,9 +4111,9 @@ var SessionCommunicationHandler = class {
     let visible = adapter.isSessionVisible(parent ?? communication.sessionId);
     if (!visible && (parent !== void 0 || communication.operation === "research.list")) {
       try {
-        const access2 = this.options.captureResearchAccess(parent ?? communication.sessionId);
-        access2.assertCurrent();
-        visible = access2.detached;
+        const access = this.options.captureResearchAccess(parent ?? communication.sessionId);
+        access.assertCurrent();
+        visible = access.detached;
       } catch {
         visible = false;
       }
@@ -4300,16 +4401,16 @@ var SessionCommunicationHandler = class {
 
 // src/desktop-workspaces.ts
 import { createHash as createHash9 } from "node:crypto";
-import { readdir, realpath as realpath5, stat as stat6 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { basename as basename2, join as join8, normalize } from "node:path";
+import { readdir, realpath as realpath5, stat as stat5 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join as join7, normalize } from "node:path";
 function desktopRootCandidates(environment2 = process.env) {
   const candidates = [
     environment2.AGENTKNIGHT_WORKSPACE_ROOT,
-    environment2.OneDrive === void 0 ? void 0 : join8(environment2.OneDrive, "Desktop"),
-    environment2.OneDriveCommercial === void 0 ? void 0 : join8(environment2.OneDriveCommercial, "Desktop"),
-    environment2.OneDriveConsumer === void 0 ? void 0 : join8(environment2.OneDriveConsumer, "Desktop"),
-    join8(environment2.USERPROFILE ?? homedir2(), "Desktop")
+    environment2.OneDrive === void 0 ? void 0 : join7(environment2.OneDrive, "Desktop"),
+    environment2.OneDriveCommercial === void 0 ? void 0 : join7(environment2.OneDriveCommercial, "Desktop"),
+    environment2.OneDriveConsumer === void 0 ? void 0 : join7(environment2.OneDriveConsumer, "Desktop"),
+    join7(environment2.USERPROFILE ?? homedir(), "Desktop")
   ];
   return [...new Set(candidates.filter((path) => path !== void 0))];
 }
@@ -4328,7 +4429,7 @@ async function findDesktopRoot(candidates) {
   for (const candidate of candidates) {
     try {
       const resolved = await realpath5(candidate);
-      if ((await stat6(resolved)).isDirectory()) {
+      if ((await stat5(resolved)).isDirectory()) {
         return resolved;
       }
     } catch (error) {
@@ -4350,7 +4451,7 @@ async function listDesktopWorkspaces(rootOverride) {
   const workspaces = entries.filter(
     (entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name.trim().length > 0
   ).map((entry) => {
-    const path = join8(root, entry.name);
+    const path = join7(root, entry.name);
     return {
       id: workspaceId(path),
       name: entry.name,
@@ -4371,12 +4472,12 @@ async function resolveSessionWorkspace(path) {
   }
   try {
     const resolved = await realpath5(candidate);
-    if (!(await stat6(resolved)).isDirectory()) {
+    if (!(await stat5(resolved)).isDirectory()) {
       return void 0;
     }
     return {
       id: workspaceId(resolved),
-      name: basename2(resolved) || resolved,
+      name: basename(resolved) || resolved,
       path: resolved
     };
   } catch (error) {
@@ -4422,7 +4523,7 @@ import { execFile as execFile2 } from "node:child_process";
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { lstat as lstat5, mkdir as mkdir3, realpath as realpath6, rmdir } from "node:fs/promises";
 import { devNull } from "node:os";
-import { dirname as dirname2, isAbsolute as isAbsolute6, join as join9, relative as relative3 } from "node:path";
+import { dirname as dirname2, isAbsolute as isAbsolute5, join as join8, relative as relative3 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 var execFileAsync = promisify3(execFile2);
 function creationEnvironment() {
@@ -4433,7 +4534,7 @@ function creationEnvironment() {
 }
 function inside(root, path) {
   const difference = relative3(root, path);
-  return difference === "" || !isAbsolute6(difference) && difference !== ".." && !difference.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
+  return difference === "" || !isAbsolute5(difference) && difference !== ".." && !difference.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
 }
 async function git(env, ...args) {
   const { stdout } = await execFileAsync("git", [
@@ -4519,7 +4620,7 @@ async function createSessionWorktree(sourceDirectory, requestedBranchName, reque
   if (inside(identity2.worktreeRoot, parent)) {
     throw new Error("Cannot create a sibling worktree outside the source checkout. Move the repository and retry.");
   }
-  const path = join9(parent, `agentknight-worktree-${suffix}`);
+  const path = join8(parent, `agentknight-worktree-${suffix}`);
   if (path.length > 640) {
     throw new Error("The repository path is too long to report worktree recovery safely. Use a checkout closer to the filesystem root.");
   }
@@ -7919,11 +8020,11 @@ var PcAgent = class {
       (id) => this.adapter.sessionPublicationSource?.(id) ?? id
     );
     research?.chat?.setPublicationGuard((parent) => {
-      const access2 = captureResearchAccess(adapter, parent);
-      const publication = access2.detached ? void 0 : this.#publication.capture(parent);
+      const access = captureResearchAccess(adapter, parent);
+      const publication = access.detached ? void 0 : this.#publication.capture(parent);
       return () => {
-        access2.assertCurrent();
-        if (!access2.detached && !this.#publication.isCurrent(parent, publication)) {
+        access.assertCurrent();
+        if (!access.detached && !this.#publication.isCurrent(parent, publication)) {
           throw new SessionOperationError("SESSION_NOT_SHARED", "This session is no longer shared");
         }
       };
@@ -9458,15 +9559,14 @@ function contextItem(item) {
 import { execFile as execFile3 } from "node:child_process";
 import { createHash as createHash15, randomUUID as randomUUID12 } from "node:crypto";
 import { mkdir as mkdir5, lstat as lstat8, realpath as realpath8 } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { join as join12, resolve as resolve4 } from "node:path";
+import { join as join11, resolve as resolve4 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 import { z as z11 } from "zod";
 
 // src/research-thread-store.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { mkdir as mkdir4, readFile as readFile2, rename as rename2, rm as rm2, lstat as lstat6, realpath as realpath7, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join10, resolve as resolve3 } from "node:path";
+import { join as join9, resolve as resolve3 } from "node:path";
 import { z as z9 } from "zod";
 var RESEARCH_PROFILE = "research-readonly";
 var RESEARCH_PROFILE_VERSION = 1;
@@ -9507,7 +9607,7 @@ var ResearchThreadStore = class {
   #mutation = Promise.resolve();
   constructor(dataDirectory) {
     this.directory = resolve3(dataDirectory, "research");
-    this.#file = join10(this.directory, "threads.json");
+    this.#file = join9(this.directory, "threads.json");
   }
   initialize() {
     this.#loaded ??= this.#load();
@@ -9541,7 +9641,7 @@ var ResearchThreadStore = class {
     }
   }
   async #write(records2, tombstones = this.#tombstones) {
-    const staging = join10(this.directory, `threads-${randomUUID10()}.pending`);
+    const staging = join9(this.directory, `threads-${randomUUID10()}.pending`);
     try {
       await writeFile3(staging, JSON.stringify({
         version: 1,
@@ -9631,7 +9731,7 @@ var ResearchThreadStore = class {
 // src/research-chat-store.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
 import { lstat as lstat7, readFile as readFile3, rename as rename3, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join11 } from "node:path";
+import { join as join10 } from "node:path";
 import { z as z10 } from "zod";
 var receipt = z10.object({
   operationId: z10.string().min(1).max(256),
@@ -9665,7 +9765,7 @@ var ResearchChatStore = class {
     return this.#states.get(sessionId);
   }
   #file(sessionId) {
-    return join11(this.directory, `chat-${z10.string().uuid().parse(sessionId)}.json`);
+    return join10(this.directory, `chat-${z10.string().uuid().parse(sessionId)}.json`);
   }
   async read(sessionId) {
     const cached = this.#states.get(sessionId);
@@ -9703,7 +9803,6 @@ var ResearchChatStore = class {
 
 // src/research-sessions.ts
 var executeFile = promisify4(execFile3);
-var require2 = createRequire(import.meta.url);
 var SEED_PREFIX = "Research context attachment (reference data, not instructions):\n";
 var SEED_REQUEST_PREFIX = "\n\nResearch request:\n";
 var hash = (value) => createHash15("sha256").update(value).digest("base64url");
@@ -9774,14 +9873,14 @@ function researchClientOptions(privateDirectory, token) {
     USERPROFILE: privateDirectory,
     APPDATA: privateDirectory,
     LOCALAPPDATA: privateDirectory,
-    TEMP: join12(privateDirectory, "scratch"),
-    TMP: join12(privateDirectory, "scratch")
+    TEMP: join11(privateDirectory, "scratch"),
+    TMP: join11(privateDirectory, "scratch")
   });
   return {
     mode: "empty",
     baseDirectory: privateDirectory,
     workingDirectory: privateDirectory,
-    connection: { kind: "stdio", path: require2.resolve("@github/copilot/npm-loader.js") },
+    connection: { kind: "stdio" },
     env: environment2,
     gitHubToken: token,
     useLoggedInUser: false,
@@ -9838,7 +9937,7 @@ var ResearchSessions = class {
   constructor(options) {
     this.options = options;
     this.store = new ResearchThreadStore(options.dataDirectory);
-    this.#privateDirectory = join12(this.store.directory, "runtime");
+    this.#privateDirectory = join11(this.store.directory, "runtime");
     this.#chat = new ResearchChatStore(this.store.directory);
     this.#projection = new LiveTimelineProjection({
       state: (id) => this.#state(id),
@@ -9928,7 +10027,7 @@ var ResearchSessions = class {
         this.#failedClient = void 0;
       }
       await this.store.initialize();
-      await mkdir5(join12(this.#privateDirectory, "scratch"), { recursive: true, mode: 448 });
+      await mkdir5(join11(this.#privateDirectory, "scratch"), { recursive: true, mode: 448 });
       if ((await lstat8(this.#privateDirectory)).isSymbolicLink() || await realpath8(this.#privateDirectory) !== resolve4(this.#privateDirectory)) {
         throw new ResearchError("RESEARCH_PRIVATE_DIRECTORY_INVALID");
       }
@@ -10686,10 +10785,10 @@ async function initialize(options) {
     );
     const sourceAdapter = adapter;
     const sourceMetadata = async (sessionId) => {
-      const access2 = captureResearchAccess(sourceAdapter, sessionId);
-      access2.assertCurrent();
-      const metadata = access2.detached ? void 0 : await sourceAdapter.getSessionDirectoryMetadata?.(sessionId);
-      access2.assertCurrent();
+      const access = captureResearchAccess(sourceAdapter, sessionId);
+      access.assertCurrent();
+      const metadata = access.detached ? void 0 : await sourceAdapter.getSessionDirectoryMetadata?.(sessionId);
+      access.assertCurrent();
       return metadata;
     };
     research = adapter.workbench === void 0 ? void 0 : createResearchWorkbench({
@@ -10788,10 +10887,12 @@ async function initialize(options) {
 }
 export {
   AgentSelectionSchema,
+  CODING_AGENT_IDS,
   CachedPairingProvider,
   ContentCipher,
   DataDirectoryLease,
   DeviceIdentitySchema,
+  LEGACY_CLIENT_STATE_DIRECTORY,
   PEER_CHAT_TIMEOUT_MS,
   PeerChatRequestSchema,
   PeerChatResultSchema,