@jun133/kitty 0.0.5 → 0.0.6

package/dist/cli.js

@@ -40,7 +40,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jun133/kitty",
-      version: "0.0.5",
+      version: "0.0.6",
       description: "Agent",
       license: "MIT",
       keywords: [
@@ -18204,10 +18204,10 @@ var require_typescript = __commonJS({
       function and(f, g) {
         return (arg) => f(arg) && g(arg);
       }
-      function or(...fs50) {
+      function or(...fs51) {
         return (...args) => {
           let lastResult;
-          for (const f of fs50) {
+          for (const f of fs51) {
             lastResult = f(...args);
             if (lastResult) {
               return lastResult;
@@ -19782,7 +19782,7 @@ ${lanes.join("\n")}
       var tracing;
       var tracingEnabled;
       ((tracingEnabled2) => {
-        let fs50;
+        let fs51;
         let traceCount = 0;
         let traceFd = 0;
         let mode;
@@ -19791,9 +19791,9 @@ ${lanes.join("\n")}
         const legend = [];
         function startTracing2(tracingMode, traceDir, configFilePath) {
           Debug.assert(!tracing, "Tracing already started");
-          if (fs50 === void 0) {
+          if (fs51 === void 0) {
             try {
-              fs50 = require("fs");
+              fs51 = require("fs");
             } catch (e) {
               throw new Error(`tracing requires having fs
 (original error: ${e.message || e})`);
@@ -19804,8 +19804,8 @@ ${lanes.join("\n")}
           if (legendPath === void 0) {
             legendPath = combinePaths(traceDir, "legend.json");
           }
-          if (!fs50.existsSync(traceDir)) {
-            fs50.mkdirSync(traceDir, { recursive: true });
+          if (!fs51.existsSync(traceDir)) {
+            fs51.mkdirSync(traceDir, { recursive: true });
           }
           const countPart = mode === "build" ? `.${process.pid}-${++traceCount}` : mode === "server" ? `.${process.pid}` : ``;
           const tracePath = combinePaths(traceDir, `trace${countPart}.json`);
@@ -19815,10 +19815,10 @@ ${lanes.join("\n")}
             tracePath,
             typesPath
           });
-          traceFd = fs50.openSync(tracePath, "w");
+          traceFd = fs51.openSync(tracePath, "w");
           tracing = tracingEnabled2;
           const meta = { cat: "__metadata", ph: "M", ts: 1e3 * timestamp(), pid: 1, tid: 1 };
-          fs50.writeSync(
+          fs51.writeSync(
             traceFd,
             "[\n" + [{ name: "process_name", args: { name: "tsc" }, ...meta }, { name: "thread_name", args: { name: "Main" }, ...meta }, { name: "TracingStartedInBrowser", ...meta, cat: "disabled-by-default-devtools.timeline" }].map((v) => JSON.stringify(v)).join(",\n")
           );
@@ -19827,10 +19827,10 @@ ${lanes.join("\n")}
         function stopTracing() {
           Debug.assert(tracing, "Tracing is not in progress");
           Debug.assert(!!typeCatalog.length === (mode !== "server"));
-          fs50.writeSync(traceFd, `
+          fs51.writeSync(traceFd, `
 ]
 `);
-          fs50.closeSync(traceFd);
+          fs51.closeSync(traceFd);
           tracing = void 0;
           if (typeCatalog.length) {
             dumpTypes(typeCatalog);
@@ -19902,11 +19902,11 @@ ${lanes.join("\n")}
         function writeEvent(eventType, phase, name, args, extras, time = 1e3 * timestamp()) {
           if (mode === "server" && phase === "checkTypes") return;
           mark("beginTracing");
-          fs50.writeSync(traceFd, `,
+          fs51.writeSync(traceFd, `,
 {"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time},"name":"${name}"`);
-          if (extras) fs50.writeSync(traceFd, `,${extras}`);
-          if (args) fs50.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
-          fs50.writeSync(traceFd, `}`);
+          if (extras) fs51.writeSync(traceFd, `,${extras}`);
+          if (args) fs51.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
+          fs51.writeSync(traceFd, `}`);
           mark("endTracing");
           measure("Tracing", "beginTracing", "endTracing");
         }
@@ -19928,9 +19928,9 @@ ${lanes.join("\n")}
           var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
           mark("beginDumpTypes");
           const typesPath = legend[legend.length - 1].typesPath;
-          const typesFd = fs50.openSync(typesPath, "w");
+          const typesFd = fs51.openSync(typesPath, "w");
           const recursionIdentityMap = /* @__PURE__ */ new Map();
-          fs50.writeSync(typesFd, "[");
+          fs51.writeSync(typesFd, "[");
           const numTypes = types.length;
           for (let i = 0; i < numTypes; i++) {
             const type = types[i];
@@ -20026,13 +20026,13 @@ ${lanes.join("\n")}
               flags: Debug.formatTypeFlags(type.flags).split("|"),
               display
             };
-            fs50.writeSync(typesFd, JSON.stringify(descriptor));
+            fs51.writeSync(typesFd, JSON.stringify(descriptor));
             if (i < numTypes - 1) {
-              fs50.writeSync(typesFd, ",\n");
+              fs51.writeSync(typesFd, ",\n");
             }
           }
-          fs50.writeSync(typesFd, "]\n");
-          fs50.closeSync(typesFd);
+          fs51.writeSync(typesFd, "]\n");
+          fs51.closeSync(typesFd);
           mark("endDumpTypes");
           measure("Dump types", "beginDumpTypes", "endDumpTypes");
         }
@@ -20040,7 +20040,7 @@ ${lanes.join("\n")}
           if (!legendPath) {
             return;
           }
-          fs50.writeFileSync(legendPath, JSON.stringify(legend));
+          fs51.writeFileSync(legendPath, JSON.stringify(legend));
         }
         tracingEnabled2.dumpLegend = dumpLegend;
       })(tracingEnabled || (tracingEnabled = {}));
@@ -226117,6 +226117,80 @@ var init_write = __esm({
   }
 });
 
+// src/tools/sendFile.ts
+var import_promises34, sendFileToolDefinition;
+var init_sendFile = __esm({
+  "src/tools/sendFile.ts"() {
+    "use strict";
+    import_promises34 = __toESM(require("fs/promises"));
+    init_shared2();
+    sendFileToolDefinition = {
+      definition: {
+        type: "function",
+        function: {
+          name: "send_file",
+          description: "Send a local file back to the conversation. Only available when the host supports file delivery (e.g. Telegram). In CLI mode this tool returns an error.",
+          parameters: {
+            type: "object",
+            properties: {
+              filePath: {
+                type: "string",
+                description: "Absolute or relative path to the local file to send."
+              },
+              fileName: {
+                type: "string",
+                description: "Optional display file name. Defaults to the basename of the file path."
+              },
+              caption: {
+                type: "string",
+                description: "Optional caption attached to the file."
+              }
+            },
+            required: ["filePath"],
+            additionalProperties: false
+          }
+        }
+      },
+      async execute(rawArgs, context) {
+        const args = parseArgs(rawArgs);
+        const filePath = readString(args.filePath, "filePath");
+        const fileName = typeof args.fileName === "string" ? args.fileName : void 0;
+        const caption = typeof args.caption === "string" ? args.caption : void 0;
+        if (!context.enqueueFile) {
+          return {
+            ok: false,
+            output: JSON.stringify({
+              ok: false,
+              error: "send_file tool is only available when the host supports file delivery (Telegram mode). The current host does not provide file delivery capability."
+            })
+          };
+        }
+        try {
+          await import_promises34.default.access(filePath);
+        } catch {
+          return {
+            ok: false,
+            output: JSON.stringify({
+              ok: false,
+              error: `File not found: ${filePath}`
+            })
+          };
+        }
+        const entryId = await context.enqueueFile(filePath, fileName, caption);
+        return okResult(
+          JSON.stringify({
+            ok: true,
+            filePath,
+            fileName: fileName ?? filePath.split(/[/\\]/).pop(),
+            caption,
+            entryId
+          })
+        );
+      }
+    };
+  }
+});
+
 // src/tools/toolCatalog.ts
 function getBuiltinTools() {
   return agentCoreToolCatalog;
@@ -226143,7 +226217,8 @@ var init_toolCatalog = __esm({
       withChangeSignal(readToolDefinition, "none"),
       withChangeSignal(writeToolDefinition, "required"),
       withChangeSignal(editToolDefinition, "required"),
-      withChangeSignal(bashToolDefinition, "none")
+      withChangeSignal(bashToolDefinition, "none"),
+      withChangeSignal(sendFileToolDefinition, "none")
     ];
   }
 });
@@ -226574,6 +226649,7 @@ var init_tools = __esm({
     init_edit();
     init_read();
     init_write();
+    init_sendFile();
     init_registry2();
     init_runtimeRegistry();
   }
@@ -226598,6 +226674,7 @@ async function executeToolCallWithRecovery(toolRegistry, toolCall, options, sess
       projectContext,
       changeStore,
       createToolRegistry,
+      enqueueFile: options.callbacks?.enqueueFile,
       recordWorksetFile: async (input) => {
         const nextSession = recordSessionWorksetFile(session, {
           cwd: options.cwd,
@@ -226904,12 +226981,12 @@ function createChangeId() {
   const random = import_node_crypto4.default.randomUUID().slice(0, 8);
   return `${date}-${random}`;
 }
-var import_node_crypto4, import_promises34, import_node_path49, ChangeStore;
+var import_node_crypto4, import_promises35, import_node_path49, ChangeStore;
 var init_store6 = __esm({
   "src/agent/changes/store.ts"() {
     "use strict";
     import_node_crypto4 = __toESM(require("crypto"));
-    import_promises34 = __toESM(require("fs/promises"));
+    import_promises35 = __toESM(require("fs/promises"));
     import_node_path49 = __toESM(require("path"));
     ChangeStore = class {
       constructor(changesDir) {
@@ -226919,7 +226996,7 @@ var init_store6 = __esm({
         const id = createChangeId();
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
         const blobDir = import_node_path49.default.join(this.changesDir, id);
-        await import_promises34.default.mkdir(blobDir, { recursive: true });
+        await import_promises35.default.mkdir(blobDir, { recursive: true });
         const operations = await Promise.all(
           input.operations.map(async (operation, index) => {
             const beforeSnapshotPath = await this.writeSnapshot(
@@ -226959,21 +227036,21 @@ var init_store6 = __esm({
           preview: input.preview,
           operations
         };
-        await import_promises34.default.mkdir(this.changesDir, { recursive: true });
-        await import_promises34.default.writeFile(this.getMetadataPath(id), `${JSON.stringify(record, null, 2)}
+        await import_promises35.default.mkdir(this.changesDir, { recursive: true });
+        await import_promises35.default.writeFile(this.getMetadataPath(id), `${JSON.stringify(record, null, 2)}
 `, "utf8");
         return record;
       }
       async list(limit = 20) {
-        await import_promises34.default.mkdir(this.changesDir, { recursive: true });
-        const entries = await import_promises34.default.readdir(this.changesDir, { withFileTypes: true });
+        await import_promises35.default.mkdir(this.changesDir, { recursive: true });
+        const entries = await import_promises35.default.readdir(this.changesDir, { withFileTypes: true });
         const changes = await Promise.all(
           entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => this.load(import_node_path49.default.basename(entry.name, ".json")))
         );
         return changes.sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, limit);
       }
       async load(id) {
-        const raw = await import_promises34.default.readFile(this.getMetadataPath(id), "utf8");
+        const raw = await import_promises35.default.readFile(this.getMetadataPath(id), "utf8");
         return JSON.parse(raw);
       }
       async loadLatestUndoable() {
@@ -226997,17 +227074,17 @@ var init_store6 = __esm({
           restoredPaths.push(operation.path);
           if (operation.beforeSnapshotPath) {
             const buffer = await this.readSnapshot(operation.beforeSnapshotPath);
-            await import_promises34.default.mkdir(import_node_path49.default.dirname(operation.path), { recursive: true });
-            await import_promises34.default.writeFile(operation.path, buffer);
+            await import_promises35.default.mkdir(import_node_path49.default.dirname(operation.path), { recursive: true });
+            await import_promises35.default.writeFile(operation.path, buffer);
             continue;
           }
-          await import_promises34.default.rm(operation.path, { force: true });
+          await import_promises35.default.rm(operation.path, { force: true });
         }
         const updated = {
           ...record,
           undoneAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await import_promises34.default.writeFile(this.getMetadataPath(updated.id), `${JSON.stringify(updated, null, 2)}
+        await import_promises35.default.writeFile(this.getMetadataPath(updated.id), `${JSON.stringify(updated, null, 2)}
 `, "utf8");
         return {
           record: updated,
@@ -227023,11 +227100,11 @@ var init_store6 = __esm({
         }
         const fileName = `${label}.bin`;
         const absolutePath = import_node_path49.default.join(blobDir, fileName);
-        await import_promises34.default.writeFile(absolutePath, buffer);
+        await import_promises35.default.writeFile(absolutePath, buffer);
         return import_node_path49.default.relative(this.changesDir, absolutePath);
       }
       async readSnapshot(relativePath) {
-        return import_promises34.default.readFile(import_node_path49.default.join(this.changesDir, relativePath));
+        return import_promises35.default.readFile(import_node_path49.default.join(this.changesDir, relativePath));
       }
     };
   }
@@ -227453,11 +227530,11 @@ function createEventId() {
 function sanitizeSessionId2(sessionId) {
   return sessionId.replace(/[^a-zA-Z0-9_.-]/g, "_");
 }
-var import_promises35, import_node_path51, SessionEventStore;
+var import_promises36, import_node_path51, SessionEventStore;
 var init_events = __esm({
   "src/session/events.ts"() {
     "use strict";
-    import_promises35 = __toESM(require("fs/promises"));
+    import_promises36 = __toESM(require("fs/promises"));
     import_node_path51 = __toESM(require("path"));
     SessionEventStore = class {
       constructor(eventsDir) {
@@ -227474,8 +227551,8 @@ var init_events = __esm({
           message: event.message,
           details: event.details
         };
-        await import_promises35.default.mkdir(this.eventsDir, { recursive: true });
-        await import_promises35.default.appendFile(this.getSessionEventPath(event.sessionId), `${JSON.stringify(record)}
+        await import_promises36.default.mkdir(this.eventsDir, { recursive: true });
+        await import_promises36.default.appendFile(this.getSessionEventPath(event.sessionId), `${JSON.stringify(record)}
 `, "utf8");
         return record;
       }
@@ -227483,7 +227560,7 @@ var init_events = __esm({
         const filePath = this.getSessionEventPath(sessionId);
         let raw = "";
         try {
-          raw = await import_promises35.default.readFile(filePath, "utf8");
+          raw = await import_promises36.default.readFile(filePath, "utf8");
         } catch (error) {
           if (error.code === "ENOENT") {
             return [];
@@ -227746,9 +227823,9 @@ var init_turn2 = __esm({
 // src/evaluation/golden.ts
 async function runGoldenEvaluationScenario(rootDir, id) {
   const workspace = import_node_path52.default.join(rootDir, ".kitty", "eval-workspaces", id);
-  await import_promises36.default.rm(workspace, { recursive: true, force: true });
-  await import_promises36.default.mkdir(workspace, { recursive: true });
-  await import_promises36.default.writeFile(import_node_path52.default.join(workspace, "golden.txt"), "before\n", "utf8");
+  await import_promises37.default.rm(workspace, { recursive: true, force: true });
+  await import_promises37.default.mkdir(workspace, { recursive: true });
+  await import_promises37.default.writeFile(import_node_path52.default.join(workspace, "golden.txt"), "before\n", "utf8");
   const initial = getInitialRuntimeConfig();
   const config = {
     ...initial,
@@ -227876,11 +227953,11 @@ function buildGoldenWorksetCheck(id, session) {
     fact: file ? `workset golden.txt read=${file.readCount} changed=${file.changedCount} change=${file.lastChangeId ?? "none"}` : "workset golden.txt absent"
   };
 }
-var import_promises36, import_node_path52;
+var import_promises37, import_node_path52;
 var init_golden = __esm({
   "src/evaluation/golden.ts"() {
     "use strict";
-    import_promises36 = __toESM(require("fs/promises"));
+    import_promises37 = __toESM(require("fs/promises"));
     import_node_path52 = __toESM(require("path"));
     init_turn();
     init_hosts();
@@ -228280,7 +228357,7 @@ function resolveSessionPickerIo(io) {
   };
 }
 async function readCliSessionChoice(promptLabel) {
-  const rl = import_promises37.default.createInterface({
+  const rl = import_promises38.default.createInterface({
     input: import_node_process2.default.stdin,
     output: import_node_process2.default.stdout,
     terminal: true
@@ -228295,11 +228372,11 @@ async function readCliSessionChoice(promptLabel) {
     rl.close();
   }
 }
-var import_promises37, import_node_process2, DEFAULT_SESSION_PICKER_LIMIT;
+var import_promises38, import_node_process2, DEFAULT_SESSION_PICKER_LIMIT;
 var init_sessionPicker = __esm({
   "src/cli/commands/sessionPicker.ts"() {
     "use strict";
-    import_promises37 = __toESM(require("readline/promises"));
+    import_promises38 = __toESM(require("readline/promises"));
     import_node_process2 = __toESM(require("process"));
     init_stdio();
     init_session2();
@@ -228477,7 +228554,7 @@ async function isSameOrDescendant2(targetPath, possibleAncestor) {
 }
 async function pathExists2(targetPath) {
   try {
-    await import_promises38.default.access(targetPath);
+    await import_promises39.default.access(targetPath);
     return true;
   } catch {
     return false;
@@ -228488,7 +228565,7 @@ async function canonicalizePathForComparison(targetPath) {
   const tail = [];
   while (true) {
     try {
-      const real = await import_promises38.default.realpath(candidate);
+      const real = await import_promises39.default.realpath(candidate);
       return tail.length > 0 ? import_node_path53.default.join(real, ...tail.reverse()) : real;
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -228503,11 +228580,11 @@ async function canonicalizePathForComparison(targetPath) {
     candidate = parent;
   }
 }
-var import_promises38, import_node_path53;
+var import_promises39, import_node_path53;
 var init_resetSupport = __esm({
   "src/project/resetSupport.ts"() {
     "use strict";
-    import_promises38 = __toESM(require("fs/promises"));
+    import_promises39 = __toESM(require("fs/promises"));
     import_node_path53 = __toESM(require("path"));
   }
 });
@@ -228542,7 +228619,7 @@ async function resetProjectRuntime(input) {
 async function removeProjectSessions(input) {
   const removedIds = [];
   try {
-    const entries = await import_promises39.default.readdir(input.sessionsDir, { withFileTypes: true });
+    const entries = await import_promises40.default.readdir(input.sessionsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".json")) {
         continue;
@@ -228552,14 +228629,14 @@ async function removeProjectSessions(input) {
       const removeById = input.currentSessionId === sessionId;
       let removeByPath = false;
       if (!removeById) {
-        const raw = await import_promises39.default.readFile(absolutePath, "utf8");
+        const raw = await import_promises40.default.readFile(absolutePath, "utf8");
         const parsed = JSON.parse(raw);
         removeByPath = await isSameOrDescendant2(String(parsed.cwd ?? ""), input.stateRootDir);
       }
       if (!removeById && !removeByPath) {
         continue;
       }
-      await import_promises39.default.rm(absolutePath, { force: true });
+      await import_promises40.default.rm(absolutePath, { force: true });
       removedIds.push(sessionId);
     }
   } catch (error) {
@@ -228573,21 +228650,21 @@ async function removeProjectChanges(input) {
   const removedIds = [];
   const removedSessionIds = new Set(input.removedSessionIds);
   try {
-    const entries = await import_promises39.default.readdir(input.changesDir, { withFileTypes: true });
+    const entries = await import_promises40.default.readdir(input.changesDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".json")) {
         continue;
       }
       const changeId = import_node_path54.default.basename(entry.name, ".json");
       const metadataPath = import_node_path54.default.join(input.changesDir, entry.name);
-      const raw = await import_promises39.default.readFile(metadataPath, "utf8");
+      const raw = await import_promises40.default.readFile(metadataPath, "utf8");
       const parsed = JSON.parse(raw);
       const remove = typeof parsed.sessionId === "string" && removedSessionIds.has(parsed.sessionId) || await isSameOrDescendant2(String(parsed.cwd ?? ""), input.stateRootDir);
       if (!remove) {
         continue;
       }
-      await import_promises39.default.rm(metadataPath, { force: true });
-      await import_promises39.default.rm(import_node_path54.default.join(input.changesDir, changeId), { recursive: true, force: true }).catch(() => null);
+      await import_promises40.default.rm(metadataPath, { force: true });
+      await import_promises40.default.rm(import_node_path54.default.join(input.changesDir, changeId), { recursive: true, force: true }).catch(() => null);
       removedIds.push(changeId);
     }
   } catch (error) {
@@ -228601,14 +228678,14 @@ async function clearProjectKittyDirectory(kittyDir) {
   const removedEntries = [];
   const preservedEntries = [];
   try {
-    const entries = await import_promises39.default.readdir(kittyDir, { withFileTypes: true });
+    const entries = await import_promises40.default.readdir(kittyDir, { withFileTypes: true });
     for (const entry of entries) {
       const absolutePath = import_node_path54.default.join(kittyDir, entry.name);
       if (PRESERVED_PROJECT_STATE_ENTRIES.has(entry.name)) {
         preservedEntries.push(entry.name);
         continue;
       }
-      await import_promises39.default.rm(absolutePath, { recursive: true, force: true });
+      await import_promises40.default.rm(absolutePath, { recursive: true, force: true });
       removedEntries.push(entry.name);
     }
   } catch (error) {
@@ -228621,11 +228698,11 @@ async function clearProjectKittyDirectory(kittyDir) {
     preservedEntries
   };
 }
-var import_promises39, import_node_path54, PRESERVED_PROJECT_STATE_ENTRIES;
+var import_promises40, import_node_path54, PRESERVED_PROJECT_STATE_ENTRIES;
 var init_reset = __esm({
   "src/project/reset.ts"() {
     "use strict";
-    import_promises39 = __toESM(require("fs/promises"));
+    import_promises40 = __toESM(require("fs/promises"));
     import_node_path54 = __toESM(require("path"));
     init_repoRoots();
     init_statePaths();
@@ -231166,23 +231243,23 @@ async function initializeProjectFiles(cwd) {
   const ignorePath = import_node_path57.default.join(kittyDir, PROJECT_STATE_IGNORE_FILE_NAME);
   const envTemplate = buildProjectEnvTemplate(false);
   const envExampleTemplate = buildProjectEnvTemplate(true);
-  await import_promises40.default.mkdir(kittyDir, { recursive: true });
+  await import_promises41.default.mkdir(kittyDir, { recursive: true });
   if (await fileExists2(envPath)) {
     skipped.push(envPath);
   } else {
-    await import_promises40.default.writeFile(envPath, envTemplate, "utf8");
+    await import_promises41.default.writeFile(envPath, envTemplate, "utf8");
     created.push(envPath);
   }
   if (await fileExists2(envExamplePath)) {
     skipped.push(envExamplePath);
   } else {
-    await import_promises40.default.writeFile(envExamplePath, envExampleTemplate, "utf8");
+    await import_promises41.default.writeFile(envExamplePath, envExampleTemplate, "utf8");
     created.push(envExamplePath);
   }
   if (await fileExists2(ignorePath)) {
     skipped.push(ignorePath);
   } else {
-    await import_promises40.default.writeFile(ignorePath, getDefaultKittyIgnoreContent(), "utf8");
+    await import_promises41.default.writeFile(ignorePath, getDefaultKittyIgnoreContent(), "utf8");
     created.push(ignorePath);
   }
   return {
@@ -231193,17 +231270,17 @@ async function initializeProjectFiles(cwd) {
 }
 async function fileExists2(targetPath) {
   try {
-    await import_promises40.default.access(targetPath);
+    await import_promises41.default.access(targetPath);
     return true;
   } catch {
     return false;
   }
 }
-var import_promises40, import_node_path57;
+var import_promises41, import_node_path57;
 var init_init = __esm({
   "src/config/init.ts"() {
     "use strict";
-    import_promises40 = __toESM(require("fs/promises"));
+    import_promises41 = __toESM(require("fs/promises"));
     import_node_path57 = __toESM(require("path"));
     init_projectEnvTemplate();
     init_ignore();
@@ -231827,11 +231904,11 @@ var botApiClient_exports = {};
 __export(botApiClient_exports, {
   FetchTelegramBotApiClient: () => FetchTelegramBotApiClient
 });
-var import_promises41, import_node_path59, FetchTelegramBotApiClient;
+var import_promises42, import_node_path59, FetchTelegramBotApiClient;
 var init_botApiClient = __esm({
   "src/telegram/botApiClient.ts"() {
     "use strict";
-    import_promises41 = __toESM(require("fs/promises"));
+    import_promises42 = __toESM(require("fs/promises"));
     import_node_path59 = __toESM(require("path"));
     FetchTelegramBotApiClient = class {
       baseUrl;
@@ -231889,7 +231966,7 @@ var init_botApiClient = __esm({
       }
       async sendDocument(request) {
         const fileName = request.fileName?.trim() || import_node_path59.default.basename(request.filePath);
-        const buffer = await import_promises41.default.readFile(request.filePath);
+        const buffer = await import_promises42.default.readFile(request.filePath);
         const form = new FormData();
         form.set("chat_id", String(request.chatId));
         form.set("document", new Blob([buffer]), fileName);
@@ -231950,7 +232027,7 @@ var init_botApiClient = __esm({
 // src/telegram/storage.ts
 async function readJsonFile2(filePath, fallback) {
   try {
-    const raw = await import_promises42.default.readFile(filePath, "utf8");
+    const raw = await import_promises43.default.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -231960,17 +232037,17 @@ async function readJsonFile2(filePath, fallback) {
   }
 }
 async function writeJsonFileAtomically(filePath, value) {
-  await import_promises42.default.mkdir(import_node_path60.default.dirname(filePath), { recursive: true });
+  await import_promises43.default.mkdir(import_node_path60.default.dirname(filePath), { recursive: true });
   const temporaryPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await import_promises42.default.writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}
+  await import_promises43.default.writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
-  await import_promises42.default.rename(temporaryPath, filePath);
+  await import_promises43.default.rename(temporaryPath, filePath);
 }
-var import_promises42, import_node_path60;
+var import_promises43, import_node_path60;
 var init_storage = __esm({
   "src/telegram/storage.ts"() {
     "use strict";
-    import_promises42 = __toESM(require("fs/promises"));
+    import_promises43 = __toESM(require("fs/promises"));
     import_node_path60 = __toESM(require("path"));
   }
 });
@@ -232609,10 +232686,10 @@ async function downloadTelegramAttachment(options) {
     );
   }
   const filesDir = import_node_path61.default.join(options.config.stateDir, "files", sanitizePathSegment(options.message.peerKey));
-  await import_promises43.default.mkdir(filesDir, { recursive: true });
+  await import_promises44.default.mkdir(filesDir, { recursive: true });
   const safeFileName = sanitizeFileName(options.message.fileName ?? `${options.message.fileUniqueId}.bin`);
   const localFilePath = import_node_path61.default.join(filesDir, `${String(options.message.updateId).padStart(8, "0")}-${safeFileName}`);
-  await import_promises43.default.writeFile(localFilePath, download);
+  await import_promises44.default.writeFile(localFilePath, download);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const record = {
     id: `${options.message.peerKey}:${options.message.messageId}:${options.message.fileUniqueId}`,
@@ -232698,11 +232775,11 @@ function readConfiguredDownloadLimit(config) {
   }
   return DEFAULT_MAX_DOWNLOAD_BYTES;
 }
-var import_promises43, import_node_path61, DEFAULT_MAX_DOWNLOAD_BYTES;
+var import_promises44, import_node_path61, DEFAULT_MAX_DOWNLOAD_BYTES;
 var init_inboundFiles = __esm({
   "src/telegram/inboundFiles.ts"() {
     "use strict";
-    import_promises43 = __toESM(require("fs/promises"));
+    import_promises44 = __toESM(require("fs/promises"));
     import_node_path61 = __toESM(require("path"));
     DEFAULT_MAX_DOWNLOAD_BYTES = 45 * 1024 * 1024;
   }
@@ -233086,9 +233163,10 @@ var init_turnDisplay2 = __esm({
 });
 
 // src/telegram/turnLogging.ts
-function createLoggedTelegramCallbacks(display, logger, context) {
+function createLoggedTelegramCallbacks(display, logger, context, enqueueFile) {
   return {
     ...display.callbacks,
+    enqueueFile,
     onStatus: (text) => {
       logger.info("phase", {
         ...context,
@@ -233181,12 +233259,26 @@ async function runTelegramTurn(options) {
       enqueueVisibleMessage: async (target, text) => options.enqueueReply(target.chatId, text),
       typingIntervalMs: options.config.telegram.typingIntervalMs
     });
-    const callbacks = createLoggedTelegramCallbacks(display, options.logger, {
-      peerKey: options.message.peerKey,
-      userId: options.message.userId,
-      chatId: options.message.chatId,
-      sessionId: session.id
-    });
+    const enqueueFile = async (filePath, fileName, caption) => {
+      const entry = await options.deliveryQueue.enqueueFile({
+        chatId: options.message.chatId,
+        filePath,
+        fileName,
+        caption
+      });
+      return entry.id;
+    };
+    const callbacks = createLoggedTelegramCallbacks(
+      display,
+      options.logger,
+      {
+        peerKey: options.message.peerKey,
+        userId: options.message.userId,
+        chatId: options.message.chatId,
+        sessionId: session.id
+      },
+      enqueueFile
+    );
     options.logger.info("starting turn", {
       peerKey: options.message.peerKey,
       userId: options.message.userId,
@@ -233551,11 +233643,11 @@ var service_exports = {};
 __export(service_exports, {
   TelegramService: () => TelegramService
 });
-var import_promises44, import_node_path62, TelegramService;
+var import_promises45, import_node_path62, TelegramService;
 var init_service = __esm({
   "src/telegram/service.ts"() {
     "use strict";
-    import_promises44 = __toESM(require("fs/promises"));
+    import_promises45 = __toESM(require("fs/promises"));
     import_node_path62 = __toESM(require("path"));
     init_commandQueue();
     init_attachmentStore();
@@ -233784,7 +233876,7 @@ var init_service = __esm({
         await this.options.deliveryQueue.flushDue();
       }
       async ensureStateDirectory() {
-        await import_promises44.default.mkdir(this.options.config.telegram.stateDir, { recursive: true });
+        await import_promises45.default.mkdir(this.options.config.telegram.stateDir, { recursive: true });
       }
       trackTask(task, context) {
         const tracked = task.catch((error) => {
@@ -233831,14 +233923,14 @@ async function acquireTelegramProcessLock(options) {
   const processId = options.processId ?? process.pid;
   const pidFilePath = import_node_path63.default.join(options.stateDir, "service.pid");
   const isProcessAlive2 = options.isProcessAlive ?? defaultIsProcessAlive;
-  await import_promises45.default.mkdir(options.stateDir, { recursive: true });
+  await import_promises46.default.mkdir(options.stateDir, { recursive: true });
   const existingPid = await readPidFile(pidFilePath);
   if (existingPid && existingPid !== processId && await isProcessAlive2(existingPid)) {
     throw new Error(
       `Telegram service already running with PID ${existingPid}. Stop the existing process before starting a new one.`
     );
   }
-  await import_promises45.default.writeFile(pidFilePath, `${processId}
+  await import_promises46.default.writeFile(pidFilePath, `${processId}
 `, "utf8");
   return {
     pidFilePath,
@@ -233847,13 +233939,13 @@ async function acquireTelegramProcessLock(options) {
       if (currentPid !== processId) {
         return;
       }
-      await import_promises45.default.rm(pidFilePath, { force: true });
+      await import_promises46.default.rm(pidFilePath, { force: true });
     }
   };
 }
 async function readPidFile(filePath) {
   try {
-    const raw = await import_promises45.default.readFile(filePath, "utf8");
+    const raw = await import_promises46.default.readFile(filePath, "utf8");
     const parsed = Number.parseInt(raw.trim(), 10);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
   } catch (error) {
@@ -233874,11 +233966,11 @@ async function defaultIsProcessAlive(targetPid) {
     return false;
   }
 }
-var import_promises45, import_node_path63;
+var import_promises46, import_node_path63;
 var init_processLock = __esm({
   "src/telegram/processLock.ts"() {
     "use strict";
-    import_promises45 = __toESM(require("fs/promises"));
+    import_promises46 = __toESM(require("fs/promises"));
     import_node_path63 = __toESM(require("path"));
   }
 });