@integrity-labs/agt-cli 0.28.1113 → 0.28.1115

package/dist/mcp/direct-chat-channel.js

@@ -2988,7 +2988,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3015,7 +3015,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3590,7 +3590,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3817,7 +3817,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -11591,10 +11591,10 @@ var require_resolve_block_map = __commonJS({
       let offset = bm.offset;
       let commentEnd = null;
       for (const collItem of bm.items) {
-        const { start, key, sep: sep2, value } = collItem;
+        const { start, key, sep: sep3, value } = collItem;
         const keyProps = resolveProps.resolveProps(start, {
           indicator: "explicit-key-ind",
-          next: key ?? sep2?.[0],
+          next: key ?? sep3?.[0],
           offset,
           onError,
           parentIndent: bm.indent,
@@ -11608,7 +11608,7 @@ var require_resolve_block_map = __commonJS({
             else if ("indent" in key && key.indent !== bm.indent)
               onError(offset, "BAD_INDENT", startColMsg);
           }
-          if (!keyProps.anchor && !keyProps.tag && !sep2) {
+          if (!keyProps.anchor && !keyProps.tag && !sep3) {
             commentEnd = keyProps.end;
             if (keyProps.comment) {
               if (map.comment)
@@ -11632,7 +11632,7 @@ var require_resolve_block_map = __commonJS({
         ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
           onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
-        const valueProps = resolveProps.resolveProps(sep2 ?? [], {
+        const valueProps = resolveProps.resolveProps(sep3 ?? [], {
           indicator: "map-value-ind",
           next: value,
           offset: keyNode.range[2],
@@ -11648,7 +11648,7 @@ var require_resolve_block_map = __commonJS({
             if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024)
               onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep2, null, valueProps, onError);
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep3, null, valueProps, onError);
           if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
           offset = valueNode.range[2];
@@ -11739,7 +11739,7 @@ var require_resolve_end = __commonJS({
       let comment = "";
       if (end) {
         let hasSpace = false;
-        let sep2 = "";
+        let sep3 = "";
         for (const token of end) {
           const { source, type } = token;
           switch (type) {
@@ -11753,13 +11753,13 @@ var require_resolve_end = __commonJS({
               if (!comment)
                 comment = cb;
               else
-                comment += sep2 + cb;
-              sep2 = "";
+                comment += sep3 + cb;
+              sep3 = "";
               break;
             }
             case "newline":
               if (comment)
-                sep2 += source;
+                sep3 += source;
               hasSpace = true;
               break;
             default:
@@ -11802,18 +11802,18 @@ var require_resolve_flow_collection = __commonJS({
       let offset = fc.offset + fc.start.source.length;
       for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
-        const { start, key, sep: sep2, value } = collItem;
+        const { start, key, sep: sep3, value } = collItem;
         const props = resolveProps.resolveProps(start, {
           flow: fcName,
           indicator: "explicit-key-ind",
-          next: key ?? sep2?.[0],
+          next: key ?? sep3?.[0],
           offset,
           onError,
           parentIndent: fc.indent,
           startOnNewline: false
         });
         if (!props.found) {
-          if (!props.anchor && !props.tag && !sep2 && !value) {
+          if (!props.anchor && !props.tag && !sep3 && !value) {
             if (i === 0 && props.comma)
               onError(props.comma, "UNEXPECTED_TOKEN", `Unexpected , in ${fcName}`);
             else if (i < fc.items.length - 1)
@@ -11867,8 +11867,8 @@ var require_resolve_flow_collection = __commonJS({
             }
           }
         }
-        if (!isMap && !sep2 && !props.found) {
-          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep2, null, props, onError);
+        if (!isMap && !sep3 && !props.found) {
+          const valueNode = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, sep3, null, props, onError);
           coll.items.push(valueNode);
           offset = valueNode.range[2];
           if (isBlock(value))
@@ -11880,7 +11880,7 @@ var require_resolve_flow_collection = __commonJS({
           if (isBlock(key))
             onError(keyNode.range, "BLOCK_IN_FLOW", blockMsg);
           ctx.atKey = false;
-          const valueProps = resolveProps.resolveProps(sep2 ?? [], {
+          const valueProps = resolveProps.resolveProps(sep3 ?? [], {
             flow: fcName,
             indicator: "map-value-ind",
             next: value,
@@ -11891,8 +11891,8 @@ var require_resolve_flow_collection = __commonJS({
           });
           if (valueProps.found) {
             if (!isMap && !props.found && ctx.options.strict) {
-              if (sep2)
-                for (const st of sep2) {
+              if (sep3)
+                for (const st of sep3) {
                   if (st === valueProps.found)
                     break;
                   if (st.type === "newline") {
@@ -11909,7 +11909,7 @@ var require_resolve_flow_collection = __commonJS({
             else
               onError(valueProps.start, "MISSING_CHAR", `Missing , or : between ${fcName} items`);
           }
-          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep2, null, valueProps, onError) : null;
+          const valueNode = value ? composeNode(ctx, value, valueProps, onError) : valueProps.found ? composeEmptyNode(ctx, valueProps.end, sep3, null, valueProps, onError) : null;
           if (valueNode) {
             if (isBlock(value))
               onError(valueNode.range, "BLOCK_IN_FLOW", blockMsg);
@@ -12089,7 +12089,7 @@ var require_resolve_block_scalar = __commonJS({
           chompStart = i + 1;
       }
       let value = "";
-      let sep2 = "";
+      let sep3 = "";
       let prevMoreIndented = false;
       for (let i = 0; i < contentStart; ++i)
         value += lines[i][0].slice(trimIndent) + "\n";
@@ -12106,24 +12106,24 @@ var require_resolve_block_scalar = __commonJS({
           indent = "";
         }
         if (type === Scalar.Scalar.BLOCK_LITERAL) {
-          value += sep2 + indent.slice(trimIndent) + content;
-          sep2 = "\n";
+          value += sep3 + indent.slice(trimIndent) + content;
+          sep3 = "\n";
         } else if (indent.length > trimIndent || content[0] === "	") {
-          if (sep2 === " ")
-            sep2 = "\n";
-          else if (!prevMoreIndented && sep2 === "\n")
-            sep2 = "\n\n";
-          value += sep2 + indent.slice(trimIndent) + content;
-          sep2 = "\n";
+          if (sep3 === " ")
+            sep3 = "\n";
+          else if (!prevMoreIndented && sep3 === "\n")
+            sep3 = "\n\n";
+          value += sep3 + indent.slice(trimIndent) + content;
+          sep3 = "\n";
           prevMoreIndented = true;
         } else if (content === "") {
-          if (sep2 === "\n")
+          if (sep3 === "\n")
             value += "\n";
           else
-            sep2 = "\n";
+            sep3 = "\n";
         } else {
-          value += sep2 + content;
-          sep2 = " ";
+          value += sep3 + content;
+          sep3 = " ";
           prevMoreIndented = false;
         }
       }
@@ -12305,25 +12305,25 @@ var require_resolve_flow_scalar = __commonJS({
       if (!match)
         return source;
       let res = match[1];
-      let sep2 = " ";
+      let sep3 = " ";
       let pos = first.lastIndex;
       line.lastIndex = pos;
       while (match = line.exec(source)) {
         if (match[1] === "") {
-          if (sep2 === "\n")
-            res += sep2;
+          if (sep3 === "\n")
+            res += sep3;
           else
-            sep2 = "\n";
+            sep3 = "\n";
         } else {
-          res += sep2 + match[1];
-          sep2 = " ";
+          res += sep3 + match[1];
+          sep3 = " ";
         }
         pos = line.lastIndex;
       }
       const last = /[ \t]*(.*)/sy;
       last.lastIndex = pos;
       match = last.exec(source);
-      return res + sep2 + (match?.[1] ?? "");
+      return res + sep3 + (match?.[1] ?? "");
     }
     function doubleQuotedValue(source, onError) {
       let res = "";
@@ -13131,14 +13131,14 @@ var require_cst_stringify = __commonJS({
         }
       }
     }
-    function stringifyItem({ start, key, sep: sep2, value }) {
+    function stringifyItem({ start, key, sep: sep3, value }) {
       let res = "";
       for (const st of start)
         res += st.source;
       if (key)
         res += stringifyToken(key);
-      if (sep2)
-        for (const st of sep2)
+      if (sep3)
+        for (const st of sep3)
           res += st.source;
       if (value)
         res += stringifyToken(value);
@@ -14288,18 +14288,18 @@ var require_parser = __commonJS({
         if (this.type === "map-value-ind") {
           const prev = getPrevProps(this.peek(2));
           const start = getFirstKeyStartProps(prev);
-          let sep2;
+          let sep3;
           if (scalar.end) {
-            sep2 = scalar.end;
-            sep2.push(this.sourceToken);
+            sep3 = scalar.end;
+            sep3.push(this.sourceToken);
             delete scalar.end;
           } else
-            sep2 = [this.sourceToken];
+            sep3 = [this.sourceToken];
           const map = {
             type: "block-map",
             offset: scalar.offset,
             indent: scalar.indent,
-            items: [{ start, key: scalar, sep: sep2 }]
+            items: [{ start, key: scalar, sep: sep3 }]
           };
           this.onKeyLine = true;
           this.stack[this.stack.length - 1] = map;
@@ -14452,15 +14452,15 @@ var require_parser = __commonJS({
                 } else if (isFlowToken(it.key) && !includesToken(it.sep, "newline")) {
                   const start2 = getFirstKeyStartProps(it.start);
                   const key = it.key;
-                  const sep2 = it.sep;
-                  sep2.push(this.sourceToken);
+                  const sep3 = it.sep;
+                  sep3.push(this.sourceToken);
                   delete it.key;
                   delete it.sep;
                   this.stack.push({
                     type: "block-map",
                     offset: this.offset,
                     indent: this.indent,
-                    items: [{ start: start2, key, sep: sep2 }]
+                    items: [{ start: start2, key, sep: sep3 }]
                   });
                 } else if (start.length > 0) {
                   it.sep = it.sep.concat(start, this.sourceToken);
@@ -14654,13 +14654,13 @@ var require_parser = __commonJS({
             const prev = getPrevProps(parent);
             const start = getFirstKeyStartProps(prev);
             fixFlowSeqItems(fc);
-            const sep2 = fc.end.splice(1, fc.end.length);
-            sep2.push(this.sourceToken);
+            const sep3 = fc.end.splice(1, fc.end.length);
+            sep3.push(this.sourceToken);
             const map = {
               type: "block-map",
               offset: fc.offset,
               indent: fc.indent,
-              items: [{ start, key: fc, sep: sep2 }]
+              items: [{ start, key: fc, sep: sep3 }]
             };
             this.onKeyLine = true;
             this.stack[this.stack.length - 1] = map;
@@ -17507,7 +17507,7 @@ var require_runtime = __commonJS({
         }
         return p2 && p2.lookup(name);
       };
-      _proto.resolve = function resolve(name, forWrite) {
+      _proto.resolve = function resolve2(name, forWrite) {
         var p2 = forWrite && this.isolateWrites ? void 0 : this.parent;
         var val = this.variables[name];
         if (val !== void 0) {
@@ -19237,7 +19237,7 @@ var require_loader = __commonJS({
         return _EmitterObj.apply(this, arguments) || this;
       }
       var _proto = Loader.prototype;
-      _proto.resolve = function resolve(from, to) {
+      _proto.resolve = function resolve2(from, to) {
         return path.resolve(path.dirname(from), to);
       };
       _proto.isRelative = function isRelative(filename) {
@@ -19448,10 +19448,10 @@ var require_readdirp = __commonJS({
       }
       async _formatEntry(dirent, path) {
         let entry;
-        const basename = this._isDirent ? dirent.name : dirent;
+        const basename2 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, node_path_1.resolve)((0, node_path_1.join)(path, basename));
-          entry = { path: (0, node_path_1.relative)(this._root, fullPath), fullPath, basename };
+          const fullPath = (0, node_path_1.resolve)((0, node_path_1.join)(path, basename2));
+          entry = { path: (0, node_path_1.relative)(this._root, fullPath), fullPath, basename: basename2 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
           this._onError(err);
@@ -19521,9 +19521,9 @@ var require_readdirp = __commonJS({
       return new ReaddirpStream(options);
     }
     function readdirpPromise(root, options = {}) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         const files = [];
-        readdirp(root, options).on("data", (entry) => files.push(entry)).on("end", () => resolve(files)).on("error", (error2) => reject(error2));
+        readdirp(root, options).on("data", (entry) => files.push(entry)).on("end", () => resolve2(files)).on("error", (error2) => reject(error2));
       });
     }
     exports.default = readdirp;
@@ -20008,9 +20008,9 @@ var require_handler = __commonJS({
       _watchWithNodeFs(path, listener) {
         const opts = this.fsw.options;
         const directory = sysPath.dirname(path);
-        const basename = sysPath.basename(path);
+        const basename2 = sysPath.basename(path);
         const parent = this.fsw._getWatchedDir(directory);
-        parent.add(basename);
+        parent.add(basename2);
         const absolutePath = sysPath.resolve(path);
         const options = {
           persistent: opts.persistent
@@ -20020,7 +20020,7 @@ var require_handler = __commonJS({
         let closer;
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
-          options.interval = enableBin && isBinaryPath(basename) ? opts.binaryInterval : opts.interval;
+          options.interval = enableBin && isBinaryPath(basename2) ? opts.binaryInterval : opts.interval;
           closer = setFsWatchFileListener(path, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
@@ -20043,10 +20043,10 @@ var require_handler = __commonJS({
           return;
         }
         const dirname4 = sysPath.dirname(file);
-        const basename = sysPath.basename(file);
+        const basename2 = sysPath.basename(file);
         const parent = this.fsw._getWatchedDir(dirname4);
         let prevStats = stats;
-        if (parent.has(basename))
+        if (parent.has(basename2))
           return;
         const listener = async (path, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
@@ -20071,9 +20071,9 @@ var require_handler = __commonJS({
                 prevStats = newStats2;
               }
             } catch (error2) {
-              this.fsw._remove(dirname4, basename);
+              this.fsw._remove(dirname4, basename2);
             }
-          } else if (parent.has(basename)) {
+          } else if (parent.has(basename2)) {
             const at = newStats.atimeMs;
             const mt = newStats.mtimeMs;
             if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -20167,7 +20167,7 @@ var require_handler = __commonJS({
             this._addToNodeFs(path, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           if (!stream)
             return reject();
           stream.once(exports.STR_END, () => {
@@ -20176,7 +20176,7 @@ var require_handler = __commonJS({
               return;
             }
             const wasThrottled = throttler ? throttler.clear() : false;
-            resolve(void 0);
+            resolve2(void 0);
             previous.getChildren().filter((item) => {
               return item !== directory && !current.has(item);
             }).forEach((item) => {
@@ -21307,11 +21307,11 @@ var require_globals = __commonJS({
         }
       };
     }
-    function _joiner(sep2) {
-      sep2 = sep2 || ",";
+    function _joiner(sep3) {
+      sep3 = sep3 || ",";
       var first = true;
       return function() {
-        var val = first ? "" : sep2;
+        var val = first ? "" : sep3;
         first = false;
         return val;
       };
@@ -21341,8 +21341,8 @@ var require_globals = __commonJS({
         cycler: function cycler() {
           return _cycler(Array.prototype.slice.call(arguments));
         },
-        joiner: function joiner(sep2) {
-          return _joiner(sep2);
+        joiner: function joiner(sep3) {
+          return _joiner(sep3);
         }
       };
     }
@@ -28188,7 +28188,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -28205,7 +28205,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -28283,7 +28283,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve(parseResult.data);
+            resolve2(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -28544,12 +28544,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
+      const timeoutId = setTimeout(resolve2, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -29419,12 +29419,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -29561,6 +29561,9 @@ function shouldRefuseImpersonatedEgress(toolName, egressTools) {
 var DIRECT_CHAT_EGRESS_TOOLS = /* @__PURE__ */ new Set([
   "direct_chat.reply",
   "direct_chat.consume",
+  // ENG-11455: puts a file into the customer's conversation storage, the
+  // Direct Chat twin of telegram.upload_file (gated above for the same reason).
+  "direct_chat.attach_file",
   "channel_request_input"
 ]);
 
@@ -32733,6 +32736,21 @@ var ASSET_TYPES = {
   // module header does not apply. Embedded as <audio src=...> in the page HTML.
   "audio/mpeg": { ext: "mp3", maxBytes: 20 * MB, enabled: true }
 };
+function sniffImageType(bytes) {
+  const b = bytes;
+  if (b.length >= 8 && b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71 && b[4] === 13 && b[5] === 10 && b[6] === 26 && b[7] === 10) {
+    return "image/png";
+  }
+  if (b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255)
+    return "image/jpeg";
+  if (b.length >= 6 && b[0] === 71 && b[1] === 73 && b[2] === 70 && b[3] === 56 && (b[4] === 55 || b[4] === 57) && b[5] === 97) {
+    return "image/gif";
+  }
+  if (b.length >= 12 && b[0] === 82 && b[1] === 73 && b[2] === 70 && b[3] === 70 && b[8] === 87 && b[9] === 69 && b[10] === 66 && b[11] === 80) {
+    return "image/webp";
+  }
+  return null;
+}
 
 // ../core/dist/integrations/augmented-live/codec.js
 var DEFAULT_CHUNK_BUDGET_BYTES = 180 * 1024;
@@ -35412,6 +35430,140 @@ var INSTALLABLE_NATIVE_INTEGRATION_IDS = INSTALLABLE_NATIVE_INTEGRATIONS.map((i)
 // ../core/dist/direct-chat/upload.js
 var MB2 = 1024 * 1024;
 var DIRECT_CHAT_UPLOAD_MAX_BYTES = 100 * MB2;
+var DIRECT_CHAT_UPLOAD_TYPES = {
+  "image/png": { ext: "png", kind: "image" },
+  "image/jpeg": { ext: "jpg", kind: "image" },
+  "image/webp": { ext: "webp", kind: "image" },
+  "image/gif": { ext: "gif", kind: "image" },
+  "application/pdf": { ext: "pdf", kind: "document" },
+  "text/plain": { ext: "txt", kind: "document" },
+  "text/csv": { ext: "csv", kind: "document" },
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": {
+    ext: "docx",
+    kind: "document"
+  },
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": {
+    ext: "xlsx",
+    kind: "document"
+  },
+  // CS-1916: PowerPoint decks. Same OOXML ZIP container as docx/xlsx, so it
+  // shares their byte verification and the document cap. Legacy binary .ppt
+  // (application/vnd.ms-powerpoint, an OLE2 file, not a ZIP) stays rejected,
+  // matching .doc/.xls, which are not allowed either.
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": {
+    ext: "pptx",
+    kind: "document"
+  }
+};
+var OOXML_EXTS = /* @__PURE__ */ new Set(["docx", "xlsx", "pptx"]);
+function normalizeUploadContentType(contentType) {
+  return (contentType ?? "").trim().toLowerCase();
+}
+function contentTypeForExtension(ext) {
+  const e = (ext ?? "").trim().toLowerCase().replace(/^\./, "");
+  const want = e === "jpeg" ? "jpg" : e;
+  if (!want)
+    return null;
+  for (const [contentType, spec] of Object.entries(DIRECT_CHAT_UPLOAD_TYPES)) {
+    if (spec.ext === want)
+      return contentType;
+  }
+  return null;
+}
+function allowedUploadExtensions() {
+  return Object.values(DIRECT_CHAT_UPLOAD_TYPES).map((s) => s.ext);
+}
+function formatUploadSize(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0)
+    return `${bytes} bytes`;
+  if (bytes >= MB2)
+    return `${Math.round(bytes / MB2)} MB`;
+  if (bytes >= 1024)
+    return `${Math.round(bytes / 1024)} KB`;
+  return `${bytes} bytes`;
+}
+function formatTooLargeMessage(byteSize, maxBytes) {
+  const size = formatUploadSize(byteSize);
+  const limit = formatUploadSize(maxBytes);
+  if (size === limit) {
+    return `File is just over the ${limit} limit.`;
+  }
+  return `File is ${size}; the limit is ${limit}.`;
+}
+var PDF_MAGIC = [37, 80, 68, 70, 45];
+var ZIP_MAGIC = [80, 75, 3, 4];
+function startsWith(bytes, sig) {
+  if (bytes.length < sig.length)
+    return false;
+  for (let i = 0; i < sig.length; i++) {
+    if (bytes[i] !== sig[i])
+      return false;
+  }
+  return true;
+}
+var DIRECT_CHAT_SNIFF_BYTES = 8192;
+function containsAscii(bytes, needle, limit = DIRECT_CHAT_SNIFF_BYTES) {
+  const sig = Array.from(needle, (ch) => ch.charCodeAt(0));
+  const end = Math.min(bytes.length, limit) - sig.length;
+  for (let i = 0; i <= end; i++) {
+    let match = true;
+    for (let j = 0; j < sig.length; j++) {
+      if (bytes[i + j] !== sig[j]) {
+        match = false;
+        break;
+      }
+    }
+    if (match)
+      return true;
+  }
+  return false;
+}
+function looksLikeText(bytes) {
+  if (sniffImageType(bytes) !== null)
+    return false;
+  if (startsWith(bytes, PDF_MAGIC) || startsWith(bytes, ZIP_MAGIC))
+    return false;
+  const sample = bytes.subarray(0, Math.min(bytes.length, 4096));
+  for (let i = 0; i < sample.length; i++) {
+    if (sample[i] === 0)
+      return false;
+  }
+  return true;
+}
+function verifyDirectChatUploadBytes(bytes, declaredContentType) {
+  const contentType = normalizeUploadContentType(declaredContentType);
+  const spec = DIRECT_CHAT_UPLOAD_TYPES[contentType];
+  if (!spec)
+    return { ok: false, reason: `content_type "${declaredContentType}" is not allowed` };
+  if (spec.kind === "image") {
+    const real = sniffImageType(bytes);
+    if (real !== contentType) {
+      return {
+        ok: false,
+        reason: `declared ${contentType} but the bytes are ${real ?? "not a recognized image"}`
+      };
+    }
+    return { ok: true, contentType, ext: spec.ext, kind: spec.kind };
+  }
+  if (contentType === "application/pdf") {
+    if (!startsWith(bytes, PDF_MAGIC))
+      return { ok: false, reason: "declared application/pdf but the bytes are not a PDF" };
+    return { ok: true, contentType, ext: spec.ext, kind: spec.kind };
+  }
+  if (OOXML_EXTS.has(spec.ext)) {
+    if (!startsWith(bytes, ZIP_MAGIC)) {
+      return { ok: false, reason: `declared ${contentType} but the bytes are not an OOXML (ZIP) container` };
+    }
+    if (!containsAscii(bytes, "[Content_Types].xml")) {
+      return { ok: false, reason: `declared ${contentType} but the ZIP is not a valid OOXML document` };
+    }
+    return { ok: true, contentType, ext: spec.ext, kind: spec.kind };
+  }
+  if (!looksLikeText(bytes)) {
+    return { ok: false, reason: `declared ${contentType} but the bytes look binary` };
+  }
+  return { ok: true, contentType, ext: spec.ext, kind: spec.kind };
+}
 
 // ../core/dist/direct-chat/notice-display.js
 var AGENT_DIRECTED_NOTICE_KINDS = [
@@ -39850,8 +40002,38 @@ import { join as join10 } from "path";
 import { existsSync as existsSync4, readFileSync as readFileSync8 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join9 } from "path";
-function defaultFlagsCachePath() {
-  return join9(homedir2(), ".augmented", "flags-cache.json");
+function hasUsableFlags(path) {
+  try {
+    if (!existsSync4(path)) return false;
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
+    if (!parsed || typeof parsed !== "object") return false;
+    const flags = parsed.flags;
+    return !!flags && typeof flags === "object" && !Array.isArray(flags);
+  } catch {
+    return false;
+  }
+}
+function cacheUpdatedAt(path) {
+  try {
+    if (!existsSync4(path)) return void 0;
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const u = parsed.updated_at;
+    return typeof u === "string" && u.length > 0 ? u : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function defaultFlagsCachePath(env2 = process.env) {
+  const hostWide = join9(homedir2(), ".augmented", "flags-cache.json");
+  const agentId = env2["AGT_AGENT_ID"]?.trim();
+  if (!agentId) return hostWide;
+  const perAgent = join9(homedir2(), ".augmented", agentId, "flags-cache.json");
+  if (!hasUsableFlags(perAgent)) return hostWide;
+  const hostWideAt = cacheUpdatedAt(hostWide);
+  const perAgentAt = cacheUpdatedAt(perAgent);
+  if (hostWideAt && (!perAgentAt || perAgentAt < hostWideAt)) return hostWide;
+  return perAgent;
 }
 function envBoolean(raw) {
   if (raw === void 0) return void 0;
@@ -39878,7 +40060,7 @@ function resolveHostBooleanFlag(opts) {
   const env2 = opts.env ?? process.env;
   const envValue = envBoolean(env2[opts.envVar]);
   if (envValue !== void 0) return envValue;
-  const cached2 = cachedBoolean(opts.key, opts.cachePath ?? defaultFlagsCachePath());
+  const cached2 = cachedBoolean(opts.key, opts.cachePath ?? defaultFlagsCachePath(env2));
   if (cached2 !== void 0) return cached2;
   return opts.defaultValue;
 }
@@ -39909,7 +40091,7 @@ function cachedMaintenanceMode(path) {
   }
 }
 function resolveMaintenanceMode(opts) {
-  const cached2 = cachedMaintenanceMode(opts?.cachePath ?? defaultFlagsCachePath());
+  const cached2 = cachedMaintenanceMode(opts?.cachePath ?? defaultFlagsCachePath(opts?.env));
   if (cached2 !== void 0) return cached2;
   return "off";
 }
@@ -40314,7 +40496,7 @@ function classifyTranscriptSince(opts) {
   }
   return newest;
 }
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 async function watchForRateLimitRefusal(opts) {
   const now = opts.now ?? (() => Date.now());
   const wait = opts.wait ?? sleep;
@@ -40356,7 +40538,7 @@ var FAST_POLL_MS = 500;
 var SLOW_POLL_MS = 3e3;
 var FAST_PHASE_MS = 1e4;
 var RETRYING_NOTICE_AFTER_MS = 3 * 6e4;
-var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep2 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 function classifyTurnFailureSince(opts) {
   const dir = opts.transcriptDir ?? agentTranscriptDir({ cwd: opts.cwd, home: opts.home });
   let entries;
@@ -40581,7 +40763,7 @@ function defaultIsPidAlive(pid) {
   }
 }
 function acquireMcpSpawnLock(args) {
-  const { agentDir, basename, options = {} } = args;
+  const { agentDir, basename: basename2, options = {} } = args;
   if (!agentDir) return { kind: "no-agent-dir" };
   const isPidAlive = options.isPidAlive ?? defaultIsPidAlive;
   const selfPid = options.selfPid ?? process.pid;
@@ -40589,7 +40771,7 @@ function acquireMcpSpawnLock(args) {
   const nowMs = options.nowMs ?? (() => Date.now());
   const lockMtimeMs = options.lockMtimeMs ?? defaultLockMtimeMs;
   const staleMs = options.staleMs ?? STALE_LOCK_MS;
-  const path = join13(agentDir, basename);
+  const path = join13(agentDir, basename2);
   const existing = readLockHolder(path);
   if (existing) {
     if (existing.pid === selfPid) {
@@ -40799,6 +40981,161 @@ async function downloadInboundAttachments(attachments, dir, deps) {
   return out;
 }
 
+// src/direct-chat-attach.ts
+import { createHash } from "crypto";
+import { constants as fsConstants, promises as fsp } from "fs";
+import { basename, extname, isAbsolute as isAbsolute2, resolve, sep as sep2 } from "path";
+import { Readable } from "stream";
+var PUT_TIMEOUT_MS = 1800 * 1e3;
+function redactUrls(text) {
+  return text.replace(/https?:\/\/\S+/g, "<url>");
+}
+function isWithin(parent, child) {
+  const p2 = parent.endsWith(sep2) ? parent : parent + sep2;
+  return child === parent || child.startsWith(p2);
+}
+async function sha256OfHandle(handle) {
+  const hash = createHash("sha256");
+  await new Promise((resolvePromise, reject) => {
+    const stream = handle.createReadStream({ start: 0, autoClose: false });
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolvePromise());
+    stream.on("error", reject);
+  });
+  return hash.digest("hex");
+}
+async function attachWorkspaceFile(input, deps) {
+  const rawPath = typeof input.path === "string" ? input.path.trim() : "";
+  if (!rawPath) return { ok: false, error: "path is required" };
+  if (!input.sessionId) return { ok: false, error: "session_id is required" };
+  if (!deps.agentRoot) {
+    return { ok: false, error: "cannot resolve your workspace directory on this host, so no file can be attached" };
+  }
+  const candidate = isAbsolute2(rawPath) ? rawPath : resolve(deps.cwd, rawPath);
+  let realRoot;
+  try {
+    realRoot = await fsp.realpath(deps.agentRoot);
+  } catch {
+    return { ok: false, error: "cannot resolve your workspace directory on this host, so no file can be attached" };
+  }
+  let handle;
+  try {
+    handle = await fsp.open(candidate, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
+  } catch {
+    return { ok: false, error: `no such file: ${rawPath}` };
+  }
+  try {
+    if (deps.afterOpenForTest) await deps.afterOpenForTest();
+    let size;
+    let realFile;
+    try {
+      const opened = await handle.stat();
+      if (!opened.isFile()) return { ok: false, error: `${rawPath} is not a regular file` };
+      realFile = await fsp.realpath(candidate);
+      if (!isWithin(realRoot, realFile)) {
+        return {
+          ok: false,
+          error: `${rawPath} is outside your workspace; only files under your own agent directory can be attached`
+        };
+      }
+      const atPath = await fsp.stat(realFile);
+      if (atPath.dev !== opened.dev || atPath.ino !== opened.ino) {
+        return { ok: false, error: `${rawPath} changed while it was being attached; try again` };
+      }
+      size = opened.size;
+    } catch {
+      return { ok: false, error: `cannot read ${rawPath}` };
+    }
+    if (size <= 0) return { ok: false, error: `${rawPath} is empty` };
+    if (size > DIRECT_CHAT_UPLOAD_MAX_BYTES) {
+      return { ok: false, error: formatTooLargeMessage(size, DIRECT_CHAT_UPLOAD_MAX_BYTES) };
+    }
+    const filename = basename(realFile);
+    const contentType = contentTypeForExtension(extname(filename));
+    if (!contentType) {
+      return {
+        ok: false,
+        error: `${filename} has a file type that cannot be attached. Allowed: ${allowedUploadExtensions().join(", ")}`
+      };
+    }
+    let head;
+    try {
+      const buf = Buffer.alloc(DIRECT_CHAT_SNIFF_BYTES);
+      const { bytesRead } = await handle.read(buf, 0, DIRECT_CHAT_SNIFF_BYTES, 0);
+      head = new Uint8Array(buf.subarray(0, bytesRead));
+    } catch {
+      return { ok: false, error: `cannot read ${rawPath}` };
+    }
+    const sniff = verifyDirectChatUploadBytes(head, contentType);
+    if (!sniff.ok) {
+      return { ok: false, error: `${filename} does not contain what its extension says (${sniff.reason})` };
+    }
+    let sha256;
+    try {
+      sha256 = await sha256OfHandle(handle);
+    } catch {
+      return { ok: false, error: `cannot read ${rawPath}` };
+    }
+    let minted;
+    try {
+      const res = await deps.apiPost("/host/direct-chat/uploads", {
+        agent_id: deps.agentId,
+        session_id: input.sessionId,
+        filename,
+        content_type: contentType,
+        byte_size: size,
+        sha256
+      });
+      minted = await res.json().catch(() => ({})) ?? {};
+      if (!res.ok || !minted.upload_id || !minted.upload_url) {
+        return {
+          ok: false,
+          error: redactUrls(`could not start the upload: ${minted.error ?? `HTTP ${res.status}`}`)
+        };
+      }
+    } catch (err) {
+      return { ok: false, error: redactUrls(`could not start the upload: ${err.message}`) };
+    }
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    try {
+      const body = Readable.toWeb(handle.createReadStream({ start: 0, autoClose: false }));
+      const put = await fetchImpl(minted.upload_url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": contentType,
+          "If-None-Match": "*",
+          "Content-Length": String(size)
+        },
+        body,
+        // Required by Node's fetch for a streamed request body.
+        duplex: "half",
+        // Bounded by the presigned URL's own 30-minute validity: past that the PUT
+        // cannot succeed anyway, so do not hold the tool call open beyond it.
+        signal: AbortSignal.timeout(PUT_TIMEOUT_MS)
+      });
+      if (!(put.ok || put.status === 412)) {
+        return { ok: false, error: `upload of ${filename} failed (HTTP ${put.status})` };
+      }
+    } catch (err) {
+      return { ok: false, error: redactUrls(`upload of ${filename} failed: ${err.message}`) };
+    }
+    return { ok: true, file: { upload_id: minted.upload_id, filename, content_type: contentType, byte_size: size } };
+  } finally {
+    await handle.close().catch(() => void 0);
+  }
+}
+function replySentText(data) {
+  const linked = data?.attachments_linked ?? [];
+  const rejected = data?.attachments_rejected ?? [];
+  if (rejected.length > 0) {
+    const list = rejected.map((r) => `${r.upload_id} (${redactUrls(r.reason)})`).join("; ");
+    const attached = linked.length > 0 ? ` with ${linked.length} attachment(s)` : "";
+    return `sent${attached}, but ${rejected.length} file(s) were NOT attached: ${list}. Tell the user, or fix and attach again in a follow-up reply.`;
+  }
+  if (linked.length > 0) return `sent with ${linked.length} attachment(s): ${linked.map((l) => l.filename).join(", ")}`;
+  return "sent";
+}
+
 // src/direct-chat-structured-payload.ts
 var RENDERED_KINDS = /* @__PURE__ */ new Set(["form_result", "button_click"]);
 var MAX_RENDERED_CHARS = 4e3;
@@ -41434,12 +41771,16 @@ function buildDirectChatMcpInstructions() {
     "Always reply to every direct chat message that expects a reply (its meta has requires_reply=true, or no requires_reply field) \u2014 the user is waiting in the webapp.",
     "NEVER call direct_chat_reply for a NOTICE \u2014 a notification whose meta has requires_reply=false (ENG-6381). It is an informational FYI (e.g. an integration-status update), not a question, and it has ALREADY been acknowledged for you. Replying would wrongly post into the operator\u2019s chat history and burn a turn. Just take it into account and carry on.",
     "In the rare case you deliberately handle a reply-expecting message without replying (e.g. an internal command), call direct_chat_consume with the session_id so it is not treated as undelivered and redelivered.",
-    "Keep replies concise and helpful. You have full access to all your MCP tools."
+    // ENG-11455: replaces "You have full access to all your MCP tools", which
+    // told the agent nothing it could act on. This blob is within ~40 chars of
+    // the 2048 cap (eng-9649), so the file procedure lives in the
+    // direct_chat_attach_file tool description; this line only points at it.
+    "Keep replies concise. To send a file: direct_chat_attach_file, then its upload_id in direct_chat_reply upload_ids."
   ].join(" ");
 }
 
 // src/usage-limit-reactive-decision.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function shouldArmWatch(opts) {
   return !opts.isBot && opts.replyOwed;
 }
@@ -41474,7 +41815,7 @@ function decideUsageLimitCursorCall(opts) {
 }
 function describeUnparsedRefusal(text) {
   if (!text) return "refusal=absent";
-  const hash = createHash("sha256").update(text).digest("hex").slice(0, 12);
+  const hash = createHash2("sha256").update(text).digest("hex").slice(0, 12);
   return `refusal_hash=${hash} refusal_len=${text.length}`;
 }
 
@@ -41503,6 +41844,12 @@ var INBOUND_ATTACHMENTS_DIR = resolveInboundAttachmentsDir({
   agentId: AGT_AGENT_ID,
   homeDir: homedir5()
 });
+var OUTBOUND_ATTACHMENT_ROOT = resolveAgentDirAlias({
+  codeName: process.env.AGT_AGENT_CODE_NAME,
+  turnInitiatorFile: process.env.AGT_TURN_INITIATOR_FILE,
+  agentId: AGT_AGENT_ID,
+  homeDir: homedir5()
+});
 var AGT_AGENT_CODE_NAME = process.env.AGT_AGENT_CODE_NAME;
 var directChatStderrLogStream = null;
 if (AGT_AGENT_CODE_NAME) {
@@ -41701,7 +42048,7 @@ var STREAM_REPLY_FLUSH_MS = (() => {
   const n = raw ? Number(raw) : NaN;
   return Number.isFinite(n) && n >= 0 ? n : 60;
 })();
-var sleep3 = (ms) => ms > 0 ? new Promise((resolve) => setTimeout(resolve, ms)) : Promise.resolve();
+var sleep3 = (ms) => ms > 0 ? new Promise((resolve2) => setTimeout(resolve2, ms)) : Promise.resolve();
 async function apiPost(path, body) {
   const token = await getAuthToken();
   const res = await fetchWithTimeout(`${AGT_HOST}${path}`, {
@@ -41914,11 +42261,38 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
           content: {
             type: "string",
             description: "The reply message (supports markdown)"
+          },
+          upload_ids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Files to attach to this reply: the upload_id values returned by direct_chat_attach_file in this same session (up to 10). The user downloads them from the chips under your message."
           }
         },
         required: ["session_id", "content"]
       }
     },
+    {
+      // ENG-11455: the Direct Chat counterpart of slack_upload_file. Uploads a
+      // workspace file through the existing, verified upload path and returns an
+      // upload_id to pass to direct_chat_reply. The storage URL never reaches
+      // the agent (see direct-chat-attach.ts).
+      name: "direct_chat.attach_file",
+      description: "Attach a file from your workspace to a Direct Chat reply. Uploads it and returns an upload_id; then call direct_chat_reply with upload_ids: [that id] to send it. Allowed types: png, jpg, webp, gif, pdf, txt, csv, docx, xlsx, pptx, up to 100 MB. The file must really be what its extension says. Only files under your own agent directory can be attached.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          session_id: {
+            type: "string",
+            description: "Session ID (from the session_id attribute in the <channel> tag)"
+          },
+          path: {
+            type: "string",
+            description: "Absolute path to the file (recommended). Must be under your own agent directory (~/.augmented/<code_name>/), e.g. in project/ or scratch/. A relative path resolves against your working directory."
+          }
+        },
+        required: ["session_id", "path"]
+      }
+    },
     {
       name: "direct_chat.consume",
       description: "Acknowledge direct-chat message(s) you handled WITHOUT sending a reply (e.g. a command that only updated state, or a message you deliberately ignored). Pass the session_id from the <channel> tag. If you send a direct_chat_reply you do NOT also need to consume \u2014 the reply already acknowledges the message. Without one of the two, a silently-handled message is treated as undelivered and may be redelivered.",
@@ -41991,7 +42365,23 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
     };
   }
   if (name === "direct_chat.reply") {
-    const { session_id, content: rawContent } = args;
+    const { session_id, content: rawContent, upload_ids: rawUploadIds } = args;
+    let upload_ids;
+    if (rawUploadIds !== void 0) {
+      if (!Array.isArray(rawUploadIds) || rawUploadIds.some((x) => typeof x !== "string" || !x)) {
+        return {
+          content: [{ type: "text", text: "upload_ids must be an array of upload_id strings from direct_chat_attach_file" }],
+          isError: true
+        };
+      }
+      if (rawUploadIds.length > 10) {
+        return {
+          content: [{ type: "text", text: "At most 10 files can be attached to one reply" }],
+          isError: true
+        };
+      }
+      upload_ids = rawUploadIds.length > 0 ? rawUploadIds : void 0;
+    }
     if (rawContent == null) {
       return {
         content: [{ type: "text", text: "Missing required argument: content" }],
@@ -42018,7 +42408,9 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
           agent_id: AGT_AGENT_ID,
           session_id,
           content: slices[0],
-          message_ids
+          message_ids,
+          // ENG-11455: files bind to the anchor row, the one that persists.
+          ...upload_ids ? { upload_ids } : {}
         });
         const { body: data, httpOk, statusText } = await readCursorAdvanceBody(res);
         const verdict = judgeCursorAdvance(
@@ -42074,7 +42466,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         await maybeSendDirectChatAccountWarn(session_id);
         void maybeSendDirectChatToolsOfflineNotice(session_id).catch(() => {
         });
-        return { content: [{ type: "text", text: "sent" }] };
+        return { content: [{ type: "text", text: replySentText(data) }] };
       } catch (err) {
         return {
           content: [{ type: "text", text: `Failed: ${err.message}` }],
@@ -42087,7 +42479,8 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
         agent_id: AGT_AGENT_ID,
         session_id,
         content,
-        message_ids
+        message_ids,
+        ...upload_ids ? { upload_ids } : {}
       });
       const { body: data, httpOk, statusText } = await readCursorAdvanceBody(res);
       const verdict = judgeCursorAdvance(
@@ -42117,7 +42510,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
       await maybeSendDirectChatAccountWarn(session_id);
       void maybeSendDirectChatToolsOfflineNotice(session_id).catch(() => {
       });
-      return { content: [{ type: "text", text: "sent" }] };
+      return { content: [{ type: "text", text: replySentText(data) }] };
     } catch (err) {
       return {
         content: [{ type: "text", text: `Failed: ${err.message}` }],
@@ -42125,6 +42518,36 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
       };
     }
   }
+  if (name === "direct_chat.attach_file") {
+    const { session_id, path } = args ?? {};
+    if (!session_id || !path) {
+      return {
+        content: [{ type: "text", text: "Missing required argument: session_id and path" }],
+        isError: true
+      };
+    }
+    const result = await attachWorkspaceFile(
+      { sessionId: session_id, path },
+      { agentRoot: OUTBOUND_ATTACHMENT_ROOT, cwd: process.cwd(), apiPost, agentId: AGT_AGENT_ID }
+    );
+    if (!result.ok) {
+      return { content: [{ type: "text", text: `Not attached: ${result.error}` }], isError: true };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            upload_id: result.file.upload_id,
+            filename: result.file.filename,
+            content_type: result.file.content_type,
+            byte_size: result.file.byte_size,
+            next: "Pass this upload_id in upload_ids on direct_chat_reply (same session_id) to send the file."
+          })
+        }
+      ]
+    };
+  }
   if (name === "direct_chat.consume") {
     const { session_id } = args;
     const message_ids = claimTracker.peek(session_id);
@@ -42838,8 +43261,8 @@ if (DOORBELL_ENABLED && DIRECT_CHAT_AGENT_DIR) {
   if (sessionState.fresh) {
     void runBacklogDrain({
       attempt: () => pollOnce(void 0),
-      sleep: (ms) => new Promise((resolve) => {
-        const t = setTimeout(resolve, ms);
+      sleep: (ms) => new Promise((resolve2) => {
+        const t = setTimeout(resolve2, ms);
         t.unref?.();
       }),
       onLog: (line) => process.stderr.write(`${line}