@codexhost/cli-darwin-x64 0.16.1 → 0.17.0

package/app/plugins/deepseek-harness/plugin.mjs

@@ -5018,10 +5018,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5430,11 +5430,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -5581,16 +5581,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path9 = []) => {
+  const processError = (error52, path11 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -5617,17 +5617,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path9 = []) => {
+  const processError = (error52, path11 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path9, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path9, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path9, ...issue2.path];
+        const fullpath = [...path11, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5659,8 +5659,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path9 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path9) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18352,13 +18352,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path9 = ref.slice(1).split("/").filter(Boolean);
-  if (path9.length === 0) {
+  const path11 = ref.slice(1).split("/").filter(Boolean);
+  if (path11.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path9[0] === defsKey) {
-    const key = path9[1];
+  if (path11[0] === defsKey) {
+    const key = path11[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -20953,16 +20953,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path9, added, removed, oldPosInc, options) {
-    const last = path9.lastComponent;
+  addToPath(path11, added, removed, oldPosInc, options) {
+    const last = path11.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path11.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path9.oldPos + oldPosInc,
+        oldPos: path11.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -22569,7 +22569,7 @@ var DeepSeekGenerationProbeError = class extends Error {
       this.stderrTail = options.stderrTail;
   }
 };
-var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_TIMEOUT_MS = 15e3;
 var DEFAULT_CLEANUP_TIMEOUT_MS = 1e3;
 var DEFAULT_OUTPUT_LIMIT_BYTES = 16 * 1024;
 var DIAGNOSTIC_RAW_TAIL_BYTES = 16 * 1024;
@@ -22879,7 +22879,7 @@ async function probeDeepSeekExecutableGeneration(options = {}, dependencies = {
 
 // dist/modern/deepseek-harness-adapter.js
 import { randomUUID as randomUUID2 } from "node:crypto";
-import path8 from "node:path";
+import path10 from "node:path";
 
 // dist/modern/catalog.js
 import { Buffer as Buffer3 } from "node:buffer";
@@ -23000,7 +23000,7 @@ var ModernRemoteConnectionError = class extends Error {
       this.remoteFailure = sanitizeModernRemoteFailure(remoteFailure3);
   }
 };
-var DEFAULT_STARTUP_TIMEOUT_MS = 2e4;
+var DEFAULT_STARTUP_TIMEOUT_MS = 9e4;
 var DEFAULT_UNARY_TIMEOUT_MS = 1e4;
 var DEFAULT_STREAM_OPEN_TIMEOUT_MS = 1e4;
 var DEFAULT_CLOSE_TIMEOUT_MS = 3e3;
@@ -27096,8 +27096,369 @@ function invalidInbox() {
 }
 
 // dist/modern/history.js
+import path8 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual5 } from "node:util";
 
+// ../../harness-adapter/dist/local-media-markdown.js
+import { existsSync, statSync as statSync2 } from "node:fs";
+import path7 from "node:path";
+import { fileURLToPath } from "node:url";
+var MEDIA_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".aac",
+  ".gif",
+  ".jpeg",
+  ".jpg",
+  ".m4a",
+  ".m4v",
+  ".mov",
+  ".mp3",
+  ".mp4",
+  ".ogg",
+  ".png",
+  ".svg",
+  ".wav",
+  ".webm",
+  ".webp"
+]);
+function rewriteLocalMediaMarkdown(text, roots, options = {}) {
+  return projectLocalMedia(text, roots, options.exists ?? mediaFileExists, options.holdIncomplete === true, options.relativeImagesOnly === true).text;
+}
+var LocalMediaMarkdownStream = class {
+  #roots;
+  #exists;
+  #relativeImagesOnly;
+  #native = "";
+  #text = "";
+  /** Native text length represented by `#text`; the rest is held. */
+  #consumed = 0;
+  #verbatim = false;
+  constructor(roots, exists = mediaFileExists, options = {}) {
+    this.#roots = [...roots];
+    this.#relativeImagesOnly = options.relativeImagesOnly === true;
+    const known = /* @__PURE__ */ new Map();
+    this.#exists = (absolutePath) => {
+      let found = known.get(absolutePath);
+      if (found === void 0) {
+        found = exists(absolutePath);
+        known.set(absolutePath, found);
+      }
+      return found;
+    };
+  }
+  /** Projected text published so far: every returned delta, concatenated. */
+  get text() {
+    return this.#text;
+  }
+  /** Add native text and return the projected text it makes publishable, possibly empty. */
+  append(text) {
+    this.#native += text;
+    return this.#advance(true);
+  }
+  /** Return the projected text still held at the end of the stream. */
+  flush() {
+    return this.#advance(false);
+  }
+  #advance(holdIncomplete) {
+    const next = this.#verbatim ? void 0 : projectLocalMedia(this.#native, this.#roots, this.#exists, holdIncomplete, this.#relativeImagesOnly);
+    let delta;
+    if (next?.text.startsWith(this.#text)) {
+      delta = next.text.slice(this.#text.length);
+      this.#consumed = next.consumed;
+    } else {
+      this.#verbatim = true;
+      delta = this.#native.slice(this.#consumed);
+      this.#consumed = this.#native.length;
+    }
+    this.#text += delta;
+    return delta;
+  }
+};
+function projectLocalMedia(text, roots, exists, holdIncomplete, relativeImagesOnly) {
+  let output = "";
+  let index = 0;
+  let fence = null;
+  while (index < text.length) {
+    if (fence) {
+      const close = closingFenceEnd(text, index, fence.marker, fence.length);
+      if (close === -1)
+        break;
+      output += text.slice(index, close);
+      index = close;
+      fence = null;
+      continue;
+    }
+    const next = earliestIndex([
+      text.indexOf("![", index),
+      text.indexOf("`", index),
+      indexOfLineStartTilde(text, index)
+    ]);
+    if (next === -1)
+      break;
+    output += text.slice(index, next);
+    index = next;
+    const marker = text[next];
+    let markerLength = 1;
+    if (marker === "`" || marker === "~") {
+      let runEnd = next;
+      while (text[runEnd] === marker)
+        runEnd += 1;
+      markerLength = runEnd - next;
+      if (runEnd === text.length && holdIncomplete) {
+        return { text: output, consumed: next };
+      }
+      if (runEnd - next >= 3) {
+        const kind = fenceLineKind(text, next);
+        if (kind === "opaque")
+          break;
+        if (kind === "flat") {
+          fence = { marker, length: runEnd - next };
+          output += text.slice(next, runEnd);
+          index = runEnd;
+          continue;
+        }
+      }
+      if (marker === "~") {
+        output += text.slice(next, runEnd);
+        index = runEnd;
+        continue;
+      }
+    }
+    if (text.startsWith("![", next)) {
+      const image = parseMarkdownImage(text, next);
+      if (image.kind === "text") {
+        output += text.slice(next, image.end);
+        index = image.end;
+        continue;
+      }
+      if (image.kind === "open") {
+        if (!holdIncomplete)
+          break;
+        return { text: output + text.slice(next, image.holdFrom), consumed: image.holdFrom };
+      }
+      const resolved2 = relativeImagesOnly && /^(?:[\\/]|[a-z][a-z\d+.-]*:)/i.test(image.destination.trim()) ? null : resolveLocalMediaPath(image.destination, roots, exists);
+      output += resolved2 === null ? text.slice(next, image.end) : text.slice(next, image.destinationStart) + markdownDestination(resolved2, image.bracketed) + text.slice(image.destinationEnd, image.end);
+      index = image.end;
+      continue;
+    }
+    const code = parseInlineCode(text, next, markerLength);
+    if (code.kind !== "code" || holdIncomplete && code.end === text.length) {
+      if (holdIncomplete && code.kind !== "text")
+        return { text: output, consumed: next };
+      output += text.slice(next, next + markerLength);
+      index = next + markerLength;
+      continue;
+    }
+    const resolved = relativeImagesOnly || markerLength !== 1 || /[\r\n]/u.test(code.content) ? null : resolveLocalMediaPath(code.content, roots, exists);
+    output += resolved === null ? text.slice(next, code.end) : mediaMarkdownImage(resolved);
+    index = code.end;
+  }
+  return { text: output + text.slice(index), consumed: text.length };
+}
+function fenceLineKind(text, index) {
+  const prefix = text.slice(text.lastIndexOf("\n", index - 1) + 1, index);
+  if (prefix === "")
+    return "flat";
+  let remaining = prefix.replace(/^[ \t]+/u, "");
+  while (remaining) {
+    const marker = /^(?:>|(?:[-+*]|\d{1,9}[.)])(?=[ \t]))[ \t]*/u.exec(remaining);
+    if (!marker)
+      return null;
+    remaining = remaining.slice(marker[0].length);
+  }
+  return "opaque";
+}
+function indexOfLineStartTilde(text, start) {
+  for (let tilde = text.indexOf("~", start); tilde !== -1; tilde = text.indexOf("~", tilde + 1)) {
+    if (fenceLineKind(text, tilde) !== null)
+      return tilde;
+  }
+  return -1;
+}
+function closingFenceEnd(text, start, marker, length) {
+  const closing = new RegExp(`^ {0,3}${marker === "`" ? "`" : "~"}{${length},}[ \\t]*\\r?$`, "u");
+  let lineStart = text.indexOf("\n", start);
+  while (lineStart !== -1) {
+    lineStart += 1;
+    const newline = text.indexOf("\n", lineStart);
+    const lineEnd = newline === -1 ? text.length : newline;
+    if (closing.test(text.slice(lineStart, lineEnd)))
+      return lineEnd;
+    lineStart = newline;
+  }
+  return -1;
+}
+function earliestIndex(candidates) {
+  let next = -1;
+  for (const candidate of candidates) {
+    if (candidate === -1)
+      continue;
+    if (next === -1 || candidate < next)
+      next = candidate;
+  }
+  return next;
+}
+function parseInlineCode(text, start, length) {
+  let index = start + length;
+  while (index < text.length) {
+    const tick = text.indexOf("`", index);
+    if (/\n[^\S\n]*\n/u.test(text.slice(index, tick < 0 ? text.length : tick))) {
+      return { kind: "text" };
+    }
+    if (tick === -1)
+      break;
+    let end = tick + 1;
+    while (text[end] === "`")
+      end += 1;
+    if (end - tick === length) {
+      return { kind: "code", content: text.slice(start + length, tick), end };
+    }
+    index = end;
+  }
+  return { kind: "open" };
+}
+function parseMarkdownImage(text, start) {
+  const openLabel = { kind: "open", holdFrom: start + 2 };
+  let index = start + 2;
+  while (index < text.length) {
+    const character = text[index];
+    if (character === "\n")
+      return { kind: "text", end: start + 1 };
+    if (character === "\\") {
+      index += 2;
+      continue;
+    }
+    if (character === "]")
+      break;
+    index += 1;
+  }
+  if (index + 1 >= text.length)
+    return openLabel;
+  if (text[index + 1] !== "(")
+    return { kind: "text", end: start + 1 };
+  const destinationStart = index + 2;
+  const open = { kind: "open", holdFrom: destinationStart };
+  const malformed = { kind: "text", end: destinationStart };
+  index = skipBlanks(text, destinationStart);
+  if (index >= text.length)
+    return open;
+  let destination;
+  let destinationEnd;
+  let bracketed = false;
+  if (text[index] === "<") {
+    bracketed = true;
+    let close = index + 1;
+    while (close < text.length && text[close] !== ">" && text[close] !== "\n")
+      close += 1;
+    if (close >= text.length)
+      return open;
+    if (text[close] === "\n")
+      return malformed;
+    destination = text.slice(index + 1, close);
+    destinationEnd = close + 1;
+    index = destinationEnd;
+  } else {
+    const begin = index;
+    while (index < text.length) {
+      const character = text[index];
+      if (character === "\n" || character === " " || character === "	" || character === ")")
+        break;
+      index += character === "\\" ? 2 : 1;
+    }
+    if (index >= text.length)
+      return open;
+    destination = unescapeMarkdown(text.slice(begin, index));
+    destinationEnd = index;
+  }
+  index = skipBlanks(text, index);
+  if (index >= text.length)
+    return open;
+  const opener = text[index];
+  if (opener === '"' || opener === "'" || opener === "(") {
+    const closer = opener === "(" ? ")" : opener;
+    index += 1;
+    while (index < text.length && text[index] !== closer && text[index] !== "\n")
+      index += 1;
+    if (index >= text.length)
+      return open;
+    if (text[index] === "\n")
+      return malformed;
+    index = skipBlanks(text, index + 1);
+    if (index >= text.length)
+      return open;
+  }
+  if (text[index] !== ")")
+    return malformed;
+  return {
+    kind: "image",
+    destination,
+    destinationStart,
+    destinationEnd,
+    end: index + 1,
+    bracketed
+  };
+}
+function skipBlanks(text, start) {
+  let index = start;
+  while (text[index] === " " || text[index] === "	")
+    index += 1;
+  return index;
+}
+function mediaMarkdownImage(absolutePath) {
+  const name = path7.basename(absolutePath).replaceAll("]", "\\]");
+  return `![${name}](${markdownDestination(absolutePath, false)})`;
+}
+function markdownDestination(absolutePath, bracketed) {
+  const encoded = absolutePath.replaceAll("%", "%2525");
+  const destination = /^[A-Za-z]:\\/.test(encoded) ? encoded.replaceAll("\\", "/") : encoded.replaceAll("\\", "\\\\");
+  return bracketed || /[\s()]/.test(destination) ? `<${destination}>` : destination;
+}
+function unescapeMarkdown(value) {
+  return value.replace(/\\([\\()])/g, "$1");
+}
+function resolveLocalMediaPath(raw, roots, exists = mediaFileExists) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0 || isRemoteMediaUrl(trimmed))
+    return null;
+  const stripped = stripFileUrl(trimmed);
+  if (stripped === null)
+    return null;
+  if (isAbsoluteMediaPath(stripped)) {
+    const absolute = path7.resolve(stripped);
+    return hasMediaExtension(absolute) && exists(absolute) ? absolute : null;
+  }
+  for (const root of roots) {
+    const absolute = path7.resolve(root, stripped);
+    if (hasMediaExtension(absolute) && exists(absolute))
+      return absolute;
+  }
+  return null;
+}
+function isRemoteMediaUrl(value) {
+  return /^(?:https?:|data:|app:|blob:)/i.test(value);
+}
+function stripFileUrl(value) {
+  if (!value.toLowerCase().startsWith("file:"))
+    return value;
+  try {
+    return fileURLToPath(value);
+  } catch {
+    return null;
+  }
+}
+function isAbsoluteMediaPath(value) {
+  return path7.isAbsolute(value) || /^[a-zA-Z]:[\\/]/.test(value);
+}
+function hasMediaExtension(value) {
+  return MEDIA_EXTENSIONS.has(path7.extname(value).toLowerCase());
+}
+function mediaFileExists(absolutePath) {
+  try {
+    return existsSync(absolutePath) && statSync2(absolutePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
 // dist/modern/compaction.js
 var MODERN_CONTEXT_PRESSURE_KEY = "contextPressure";
 function modernCompactionOutcome(data) {
@@ -27715,6 +28076,8 @@ function projectModernHistory(input) {
   let effectiveThinkingOptionId = input.fallbackThinkingOptionId;
   let contextWindowTokens;
   let usage = null;
+  let workingDirectory = input.cwd;
+  const media = input.media ?? input.cwd !== void 0;
   const rawUsageByStep = /* @__PURE__ */ new Map();
   const rebuildUsage = () => {
     usage = null;
@@ -27736,6 +28099,7 @@ function projectModernHistory(input) {
     if (!KNOWN_EVENT_TYPES.has(event.type) || !isRecord4(event.data))
       continue;
     const data = event.data;
+    workingDirectory = modernWorkingDirectory(workingDirectory, event);
     switch (event.type) {
       case "turn/start":
         active = {
@@ -27780,8 +28144,9 @@ function projectModernHistory(input) {
       case "assistant/message":
         if (event.surfaceOp === "append") {
           recordSettlementUsage(data, event.seq);
-          if (active)
-            projectAssistantMessage(active, input.sessionId, data);
+          if (active) {
+            projectAssistantMessage(active, input.sessionId, data, media ? modernMediaRoots(workingDirectory, input.cwd) : void 0);
+          }
         }
         break;
       case "compaction/start":
@@ -27902,7 +28267,21 @@ function modernCheckpointRef(harnessId, sessionId, seq, profile = DEEPSEEK_V4_PR
 function modernItemId(sessionId, key) {
   return hostItemIdSchema.parse(`dsh-modern:${sessionId}:${key}`);
 }
-function projectAssistantMessage(turn, sessionId, data) {
+function modernWorkingDirectory(current, event) {
+  if (event.type !== "working-directory/change" || !isRecord4(event.data) || typeof event.data.cwd !== "string") {
+    return current;
+  }
+  const next = event.data.cwd;
+  if (path8.isAbsolute(next))
+    return path8.resolve(next);
+  return current === void 0 ? void 0 : path8.resolve(current, next);
+}
+function modernMediaRoots(workingDirectory, sessionDirectory) {
+  return [
+    ...new Set([workingDirectory ?? sessionDirectory, sessionDirectory].filter((root) => root !== void 0))
+  ];
+}
+function projectAssistantMessage(turn, sessionId, data, mediaRoots) {
   const message = data.message;
   if (Array.isArray(message.content)) {
     for (const block of message.content) {
@@ -27925,7 +28304,7 @@ function projectAssistantMessage(turn, sessionId, data) {
     const item = {
       type: "agentMessage",
       itemId: modernItemId(sessionId, `turn:${turn.turn}:step:${String(data.step)}:assistant`),
-      text
+      text: mediaRoots ? rewriteLocalMediaMarkdown(text, mediaRoots) : text
     };
     turn.items.push({ item, outcome: { status: "succeeded" } });
   }
@@ -28744,6 +29123,8 @@ var ModernHarnessSession = class {
   #flushSession;
   #fallbackModel;
   #fallbackThinkingOptionId;
+  #sessionDirectory;
+  #workingDirectory;
   #channel = new HarnessOutputChannel();
   #validator;
   #events;
@@ -28810,8 +29191,12 @@ var ModernHarnessSession = class {
     this.#events = [...options.journal.events];
     this.#historyBytes = journalHistoryBytes(this.#events, this.#maxHistoryBytes);
     this.#validator = new ModernEventValidator(this.#maxEvents, this.#profile);
-    for (const event of this.#events)
+    this.#sessionDirectory = options.journal.header.cwd;
+    this.#workingDirectory = this.#sessionDirectory;
+    for (const event of this.#events) {
       this.#validator.accept(event);
+      this.#workingDirectory = modernWorkingDirectory(this.#workingDirectory, event);
+    }
     const projection = projectModernHistory({
       harnessId: this.harnessId,
       sessionId: this.#sessionId,
@@ -28846,12 +29231,18 @@ var ModernHarnessSession = class {
     };
     let resumedAutonomousBuffer;
     if (projection.incompleteTurn) {
+      let workingDirectory = this.#sessionDirectory;
+      const turnStart = this.#events.length - projection.incompleteTurn.events.length;
+      for (const event of this.#events.slice(0, turnStart)) {
+        workingDirectory = modernWorkingDirectory(workingDirectory, event);
+      }
       const buffer = {
         nativeTurn: projection.incompleteTurn.turn,
         events: [...projection.incompleteTurn.events],
         input: [],
         initialResume: true,
         replayed: 0,
+        workingDirectory,
         sawUserMessage: false,
         reachedCorrelationBoundary: false
       };
@@ -28893,7 +29284,7 @@ var ModernHarnessSession = class {
       return Promise.resolve({ ok: false, error: busyError("read history") });
     this.#reading = true;
     try {
-      const projection = this.#project();
+      const projection = this.#project(true);
       const configuration = this.#readConfiguration();
       return Promise.resolve({
         ok: true,
@@ -29827,6 +30218,7 @@ ${question.detail}` : question.question;
     this.#validator.accept(event);
     this.#observeAssistantSettlement(event);
     this.#events.push(event);
+    this.#workingDirectory = modernWorkingDirectory(this.#workingDirectory, event);
     this.#meterUsage(event);
     this.#historyBytes += bytes;
     this.#receive(event);
@@ -29952,8 +30344,8 @@ ${question.detail}` : question.question;
     const agent = active.agent;
     if (!agent)
       return;
-    agent.text += CANCELLED_ASSISTANT_ATTEMPT_SUFFIX;
-    agent.item = { ...agent.item, text: agent.text };
+    this.#flushAgent(active, agent);
+    agent.item = { ...agent.item, text: agent.item.text + CANCELLED_ASSISTANT_ATTEMPT_SUFFIX };
     this.#emit({
       type: "item.updated",
       turnId: active.turnId,
@@ -30076,6 +30468,7 @@ ${question.detail}` : question.question;
         input: [],
         initialResume: false,
         replayed: 0,
+        workingDirectory: this.#workingDirectory,
         sawUserMessage: false,
         reachedCorrelationBoundary: false
       };
@@ -30254,6 +30647,7 @@ ${question.detail}` : question.question;
     while (!this.#closed && buffer.replayed < buffer.events.length) {
       const event = buffer.events[buffer.replayed];
       buffer.replayed += 1;
+      buffer.workingDirectory = modernWorkingDirectory(buffer.workingDirectory, event);
       this.#projectLiveEvent(buffer, event, initialReplay);
     }
     this.#projectAssistantLiveChunks();
@@ -30358,16 +30752,28 @@ ${question.detail}` : question.question;
         itemId: modernItemId(this.#sessionId, `turn:${active.nativeTurn}:step:${step}:${attemptId ? `attempt:${attemptId}:` : ""}assistant`),
         text: ""
       };
-      active.agent = { item, text: "" };
+      const buffer = this.#buffer;
+      const workingDirectory = buffer?.active === active ? buffer.workingDirectory : this.#workingDirectory;
+      const roots = modernMediaRoots(workingDirectory, this.#sessionDirectory);
+      active.agent = { item, text: "", media: new LocalMediaMarkdownStream(roots) };
       this.#emit({ type: "item.started", turnId: active.turnId, item });
     }
     active.agent.text += text;
-    active.agent.item = { ...active.agent.item, text: active.agent.text };
+    this.#publishAgent(active, active.agent, active.agent.media.append(text));
+  }
+  /** Publish text the media projection held for a trailing construct before the Item ends. */
+  #flushAgent(active, agent) {
+    this.#publishAgent(active, agent, agent.media.flush());
+  }
+  #publishAgent(active, agent, delta) {
+    if (!delta)
+      return;
+    agent.item = { ...agent.item, text: agent.media.text };
     this.#emit({
       type: "item.updated",
       turnId: active.turnId,
-      itemId: active.agent.item.itemId,
-      update: { type: "text.append", text }
+      itemId: agent.item.itemId,
+      update: { type: "text.append", text: delta }
     });
   }
   #startReasoning(active, step, provisional, attemptId) {
@@ -30455,6 +30861,7 @@ ${question.detail}` : question.question;
     }
     if (!current)
       return;
+    this.#flushAgent(active, current);
     delete active.agent;
     this.#completeItem(active, current.item, { status: "succeeded" });
   }
@@ -30596,9 +31003,10 @@ ${question.detail}` : question.question;
       this.#completeItem(active, item, outcome);
     }
     if (active.agent) {
-      const item = active.agent.item;
+      const agent = active.agent;
+      this.#flushAgent(active, agent);
       delete active.agent;
-      this.#completeItem(active, item, outcome);
+      this.#completeItem(active, agent.item, outcome);
     }
     for (const tool of active.tools.values())
       this.#completeItem(active, tool.item, outcome);
@@ -30625,12 +31033,17 @@ ${question.detail}` : question.question;
       });
     }
   }
-  #project() {
+  /** `media` also resolves local media paths, which only displayed history needs. */
+  #project(media = false) {
     return projectModernHistory({
       harnessId: this.harnessId,
       sessionId: this.#sessionId,
       events: this.#events,
       profile: this.#profile,
+      ...media ? {
+        media: true,
+        ...this.#sessionDirectory !== void 0 ? { cwd: this.#sessionDirectory } : {}
+      } : {},
       ...this.#fallbackModel ? { fallbackModel: this.#fallbackModel } : {},
       ...this.#fallbackThinkingOptionId ? { fallbackThinkingOptionId: this.#fallbackThinkingOptionId } : {},
       toolOutputLimit: this.#toolOutputLimit,
@@ -31209,7 +31622,7 @@ function safeTimerDelay(value, name) {
 
 // dist/modern/session-list.js
 import { Buffer as Buffer5 } from "node:buffer";
-import path7 from "node:path";
+import path9 from "node:path";
 var MAX_SESSION_LIST_BYTES = 32 * 1024 * 1024;
 var MAX_SESSION_LIST_DEPTH = 64;
 var MAX_SESSION_LIST_NODES = 2e5;
@@ -31329,7 +31742,7 @@ function parseSummary(value) {
   };
 }
 function isCanonicalAbsoluteCwd(value) {
-  return value !== void 0 && value.trim().length > 0 && !value.includes("\0") && path7.isAbsolute(value) && path7.resolve(value) === value;
+  return value !== void 0 && value.trim().length > 0 && !value.includes("\0") && path9.isAbsolute(value) && path9.resolve(value) === value;
 }
 function parseModernSessionCandidates(value) {
   assertBoundedJson4(value);
@@ -31527,7 +31940,7 @@ var ModernDeepSeekHarnessAdapter = class {
     let session;
     let forkExpectation;
     try {
-      const cwd = path8.resolve(input.cwd);
+      const cwd = path10.resolve(input.cwd);
       let forkInput = input.kind === "fork" ? parseModernForkInput(input, this.#profile) : void 0;
       const rollbackSourceSessionId = input.kind === "rollbackLastTurn" ? modernSessionId(input.sourceRef, "roll back") : void 0;
       let rollbackPlan;