@qwen-code/qwen-code 0.19.9 → 0.19.10-nightly.20260716.506ce0a1a

package/chunks/{chunk-N3EMS75V.js → chunk-5DEJ4T6C.js}

@@ -3,7 +3,10 @@
 import {
   formatHistoryGapNotice,
   indexGapsByChild
-} from "./chunk-U2NNEY4R.js";
+} from "./chunk-VT5AWJN4.js";
+import {
+  sanitizeTerminalText
+} from "./chunk-MFNKBXYH.js";
 import {
   require_undici
 } from "./chunk-L573Z2QZ.js";
@@ -12,13 +15,18 @@ import {
 } from "./chunk-YUZI3WAC.js";
 import {
   getActiveGoal
-} from "./chunk-NVYTCB5Z.js";
+} from "./chunk-SA6QVLWI.js";
+import {
+  apiActivityTracker,
+  formatVisionBridgeNoticeDisplay,
+  isVisionBridgeNoticeDisplay
+} from "./chunk-YYBZUIPL.js";
 import {
   ToolNames
-} from "./chunk-B5ORX3FG.js";
+} from "./chunk-JGUT3LWZ.js";
 import {
   createDebugLogger
-} from "./chunk-J4TSQ5EQ.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -27,1435 +35,1516 @@ import {
   __toESM
 } from "./chunk-J2S4EL5Y.js";
 
-// packages/cli/src/acp-integration/session/HistoryReplayer.ts
-init_esbuild_shims();
-
-// packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
+// packages/cli/src/services/setup-github.ts
 init_esbuild_shims();
+var import_undici2 = __toESM(require_undici(), 1);
+import { promises as fsp } from "node:fs";
+import * as path from "node:path";
 
-// packages/cli/src/acp-integration/session/emitters/BaseEmitter.ts
+// packages/cli/src/utils/gitUtils.ts
 init_esbuild_shims();
-var BaseEmitter = class {
-  constructor(ctx) {
-    this.ctx = ctx;
+var import_undici = __toESM(require_undici(), 1);
+import * as childProcess from "node:child_process";
+var debugLogger = createDebugLogger("GIT");
+async function runGit(args, opts = {}) {
+  return await new Promise((resolve2, reject) => {
+    childProcess.execFile(
+      "git",
+      args,
+      {
+        encoding: "utf-8",
+        ...opts.cwd ? { cwd: opts.cwd } : {}
+      },
+      (err, stdout) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve2(String(stdout ?? "").trim());
+      }
+    );
+  });
+}
+__name(runGit, "runGit");
+var isGitHubRepositoryAsync = /* @__PURE__ */ __name(async (opts = {}) => {
+  try {
+    const remotes = await runGit(["remote", "-v"], opts);
+    return remotes.split("\n").some((line) => {
+      const remoteUrl = line.trim().split(/\s+/)[1];
+      return remoteUrl ? isGitHubRemoteUrl(remoteUrl) : false;
+    });
+  } catch (_error) {
+    debugLogger.debug(`Failed to get git remote:`, _error);
+    return false;
   }
-  static {
-    __name(this, "BaseEmitter");
+}, "isGitHubRepositoryAsync");
+function isGitHubRemoteUrl(remoteUrl) {
+  if (remoteUrl.startsWith("git@github.com:")) {
+    return true;
   }
-  /**
-   * Converts an ISO timestamp string or epoch ms to epoch ms number.
-   * Returns undefined if the input is not a valid timestamp.
-   */
-  static toEpochMs(ts) {
-    if (typeof ts === "number") {
-      return Number.isFinite(ts) ? ts : void 0;
+  if (remoteUrl.startsWith("git@")) {
+    return false;
+  }
+  try {
+    return new URL(remoteUrl).hostname === "github.com";
+  } catch {
+    return false;
+  }
+}
+__name(isGitHubRemoteUrl, "isGitHubRemoteUrl");
+var getGitRepoRootAsync = /* @__PURE__ */ __name(async (opts = {}) => {
+  const gitRepoRoot = await runGit(["rev-parse", "--show-toplevel"], opts);
+  if (!gitRepoRoot) {
+    throw new Error(`Git repo returned empty value`);
+  }
+  return gitRepoRoot;
+}, "getGitRepoRootAsync");
+var getLatestGitHubRelease = /* @__PURE__ */ __name(async (proxy) => {
+  try {
+    const controller = new AbortController();
+    const endpoint = `https://api.github.com/repos/QwenLM/qwen-code-action/releases/latest`;
+    const response = await fetch(endpoint, {
+      method: "GET",
+      headers: {
+        Accept: "application/vnd.github+json",
+        "Content-Type": "application/json",
+        "X-GitHub-Api-Version": "2022-11-28"
+      },
+      dispatcher: proxy ? new import_undici.ProxyAgent(proxy) : void 0,
+      signal: AbortSignal.any([AbortSignal.timeout(3e4), controller.signal])
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Invalid response code: ${response.status} - ${response.statusText}`
+      );
     }
-    if (typeof ts === "string") {
-      const ms = new Date(ts).getTime();
-      return Number.isFinite(ms) ? ms : void 0;
+    const releaseTag = (await response.json()).tag_name;
+    if (!releaseTag) {
+      throw new Error(`Response did not include tag_name field`);
     }
-    return void 0;
+    return releaseTag;
+  } catch (_error) {
+    debugLogger.debug(
+      `Failed to determine latest qwen-code-action release:`,
+      _error
+    );
+    throw new Error(
+      `Unable to determine the latest qwen-code-action release on GitHub.`
+    );
   }
-  /**
-   * Sends a session update to the ACP client.
-   * If a message rewriter is configured, updates pass through it first
-   * (original messages are sent as-is, rewritten versions are appended).
-   */
-  async sendUpdate(update) {
-    if (this.ctx.messageRewriter) {
-      return this.ctx.messageRewriter.interceptUpdate(update);
-    }
-    return this.ctx.sendUpdate(update);
+}, "getLatestGitHubRelease");
+async function getGitHubRepoInfoAsync(opts = {}) {
+  return parseGitHubRepoInfo(
+    await runGit(["remote", "get-url", "origin"], opts)
+  );
+}
+__name(getGitHubRepoInfoAsync, "getGitHubRepoInfoAsync");
+function parseGitHubRepoInfo(remoteUrl) {
+  let urlToParse = remoteUrl;
+  if (remoteUrl.startsWith("git@github.com:")) {
+    urlToParse = remoteUrl.replace("git@github.com:", "");
+  } else if (remoteUrl.startsWith("git@")) {
+    throw new Error(
+      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`
+    );
   }
-  /**
-   * Gets the session configuration.
-   */
-  get config() {
-    return this.ctx.config;
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(urlToParse, "https://github.com");
+  } catch {
+    throw new Error(
+      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`
+    );
   }
-  /**
-   * Gets the session ID.
-   */
-  get sessionId() {
-    return this.ctx.sessionId;
+  if (parsedUrl.hostname !== "github.com") {
+    throw new Error(
+      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`
+    );
   }
-};
+  const parts = parsedUrl.pathname.split("/").filter((part) => part !== "");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(
+      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`
+    );
+  }
+  return { owner: parts[0], repo: parts[1].replace(/\.git$/, "") };
+}
+__name(parseGitHubRepoInfo, "parseGitHubRepoInfo");
 
-// packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
-var MessageEmitter = class extends BaseEmitter {
+// packages/cli/src/services/setup-github.ts
+var debugLogger2 = createDebugLogger("SETUP_GITHUB");
+var GITHUB_WORKFLOW_PATHS = [
+  "qwen-dispatch/qwen-dispatch.yml",
+  "qwen-assistant/qwen-invoke.yml",
+  "issue-triage/qwen-triage.yml",
+  "issue-triage/qwen-scheduled-triage.yml",
+  "pr-review/qwen-review.yml"
+];
+var GITIGNORE_ENTRIES = [".qwen/", "gha-creds-*.json"];
+var MAX_WORKFLOW_DOWNLOAD_BYTES = 5 * 1024 * 1024;
+var SetupGithubError = class extends Error {
   static {
-    __name(this, "MessageEmitter");
+    __name(this, "SetupGithubError");
   }
-  /**
-   * Emits a StopHookLoop event when Stop hooks create a loop.
-   * This informs the client that Stop hooks have been executed multiple times.
-   *
-   * @param iterationCount - The current iteration count
-   * @param reasons - Array of reasons from each Stop hook execution
-   * @param stopHookCount - Number of Stop hooks that were executed
-   */
-  async emitStopHookLoop(iterationCount, reasons, stopHookCount) {
-    const activeGoal = getActiveGoal(this.sessionId);
-    await this.sendUpdate({
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text: "" },
-      _meta: {
-        stopHookLoop: {
-          iterationCount,
-          reasons,
-          stopHookCount,
-          ...activeGoal ? {
-            goal: {
-              condition: activeGoal.condition,
-              iterations: activeGoal.iterations,
-              setAt: activeGoal.setAt,
-              lastReason: activeGoal.lastReason
-            }
-          } : {}
-        }
-      }
-    });
+  code;
+  status;
+  partial;
+  partialResult;
+  constructor(code, message, status, partialResult) {
+    super(message);
+    this.name = "SetupGithubError";
+    this.code = code;
+    this.status = status;
+    this.partial = partialResult !== void 0;
+    this.partialResult = partialResult;
   }
-  async emitGoalTerminal(event) {
-    await this.sendUpdate({
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text: "" },
-      _meta: {
-        goalTerminal: event
-      }
+};
+var nodeFileOps = {
+  assertCanWrite() {
+  },
+  async ensureWorkflowDirectory(gitRepoRoot) {
+    await fsp.mkdir(path.join(gitRepoRoot, ".github", "workflows"), {
+      recursive: true
     });
-  }
-  async emitGoalStatus(status) {
-    await this.sendUpdate({
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text: "" },
-      _meta: {
-        goalStatus: status
+  },
+  async writeTextFile(gitRepoRoot, relativePath, content) {
+    const target = path.join(gitRepoRoot, relativePath);
+    await fsp.writeFile(target, content, { mode: 420 });
+    return { sizeBytes: Buffer.byteLength(content, "utf8") };
+  },
+  async readTextFile(gitRepoRoot, relativePath) {
+    try {
+      return await fsp.readFile(path.join(gitRepoRoot, relativePath), "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return void 0;
       }
-    });
+      throw error;
+    }
   }
-  /**
-   * Emits a user message chunk.
-   *
-   * @param text - The user message text content
-   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
-   */
-  async emitUserMessage(text, timestamp, options = {}) {
-    const epochMs = BaseEmitter.toEpochMs(timestamp);
-    const _meta = {
-      ...epochMs != null ? { timestamp: epochMs } : {},
-      ...options.source ? { source: options.source } : {}
-    };
-    await this.sendUpdate({
-      sessionUpdate: "user_message_chunk",
-      content: { type: "text", text },
-      ...Object.keys(_meta).length > 0 ? { _meta } : {}
-    });
-  }
-  /**
-   * Emits an agent thought chunk.
-   *
-   * @param text - The thought text content
-   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
-   */
-  async emitAgentThought(text, timestamp, subagentMeta) {
-    const _meta = this.buildChunkMeta(
-      BaseEmitter.toEpochMs(timestamp),
-      subagentMeta
+};
+async function setupGithub(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const fileOps = options.fileOps ?? nodeFileOps;
+  if (!await isGitHubRepositoryAsync({ cwd })) {
+    throw new SetupGithubError(
+      "github_repository_not_found",
+      "Unable to determine the GitHub repository. /setup-github must be run from a git repository.",
+      400
     );
-    await this.sendUpdate({
-      sessionUpdate: "agent_thought_chunk",
-      content: { type: "text", text },
-      ..._meta ? { _meta } : {}
-    });
   }
-  /**
-   * Emits an agent message chunk.
-   *
-   * @param text - The agent message text content
-   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
-   */
-  async emitAgentMessage(text, timestamp, subagentMeta) {
-    const _meta = this.buildChunkMeta(
-      BaseEmitter.toEpochMs(timestamp),
-      subagentMeta
+  let gitRepoRoot;
+  try {
+    gitRepoRoot = await getGitRepoRootAsync({ cwd });
+  } catch (error) {
+    debugLogger2.debug("Failed to get git repo root:", error);
+    throw new SetupGithubError(
+      "github_repository_not_found",
+      "Unable to determine the GitHub repository. /setup-github must be run from a git repository.",
+      400
     );
-    await this.sendUpdate({
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text },
-      ..._meta ? { _meta } : {}
-    });
   }
-  /**
-   * Emits usage metadata.
-   */
-  async emitUsageMetadata(usageMetadata, text = "", durationMs, subagentMeta) {
-    const usage = {
-      inputTokens: usageMetadata.promptTokenCount ?? 0,
-      outputTokens: usageMetadata.candidatesTokenCount ?? 0,
-      totalTokens: usageMetadata.totalTokenCount ?? 0,
-      thoughtTokens: usageMetadata.thoughtsTokenCount,
-      cachedReadTokens: usageMetadata.cachedContentTokenCount
-    };
-    const cumulative = this.ctx.cumulativeUsage;
-    if (cumulative) {
-      const addFinite = /* @__PURE__ */ __name((total, value) => typeof value === "number" && Number.isFinite(value) ? total + value : total, "addFinite");
-      cumulative.promptTokens = addFinite(
-        cumulative.promptTokens,
-        usage.inputTokens
+  if (options.workspaceRoot) {
+    const [gitRootReal, workspaceReal] = await Promise.all([
+      realpathOrResolve(gitRepoRoot),
+      realpathOrResolve(options.workspaceRoot)
+    ]);
+    if (gitRootReal !== workspaceReal) {
+      throw new SetupGithubError(
+        "github_git_root_mismatch",
+        "The Git repository root must match the daemon workspace root.",
+        400
       );
-      cumulative.candidateTokens = addFinite(
-        cumulative.candidateTokens,
-        usage.outputTokens
+    }
+  }
+  fileOps.assertCanWrite?.();
+  let releaseTag;
+  try {
+    releaseTag = await getLatestGitHubRelease(options.proxy);
+  } catch (error) {
+    writeStderrLine(
+      `qwen setup-github: failed to determine latest qwen-code-action release: ${error instanceof Error ? error.message : String(error)}`
+    );
+    debugLogger2.debug(
+      "Failed to determine latest qwen-code-action release:",
+      error
+    );
+    throw new SetupGithubError(
+      "github_release_lookup_failed",
+      "Unable to determine the latest qwen-code-action release on GitHub.",
+      502
+    );
+  }
+  const readmeUrl = `https://github.com/QwenLM/qwen-code-action/blob/${releaseTag}/README.md#quick-start`;
+  const secretsUrl = await resolveSecretsUrl(cwd);
+  const downloads = await downloadWorkflows({
+    releaseTag,
+    proxy: options.proxy,
+    abortSignal: options.abortSignal,
+    fetchImpl: options.fetchImpl ?? fetch
+  });
+  const result = {
+    kind: "github_setup",
+    workspaceCwd: options.workspaceRoot ?? gitRepoRoot,
+    gitRepoRoot,
+    releaseTag,
+    readmeUrl,
+    ...secretsUrl ? { secretsUrl } : {},
+    workflows: [],
+    gitignore: { path: ".gitignore", status: "skipped" },
+    warnings: []
+  };
+  result.gitignore = await updateGitignore(gitRepoRoot, fileOps);
+  if (result.gitignore.status === "failed") {
+    result.warnings.push("Failed to update .gitignore.");
+  }
+  try {
+    await fileOps.ensureWorkflowDirectory(gitRepoRoot);
+    for (const workflow of downloads) {
+      const relativePath = path.posix.join(
+        ".github",
+        "workflows",
+        path.posix.basename(workflow.sourcePath)
       );
-      cumulative.cachedTokens = addFinite(
-        cumulative.cachedTokens,
-        usage.cachedReadTokens
+      try {
+        const write = await fileOps.writeTextFile(
+          gitRepoRoot,
+          relativePath,
+          workflow.content
+        );
+        result.workflows.push({
+          sourcePath: workflow.sourcePath,
+          path: relativePath,
+          status: "written",
+          sizeBytes: write.sizeBytes
+        });
+      } catch (error) {
+        result.partial = true;
+        result.workflows.push({
+          sourcePath: workflow.sourcePath,
+          path: relativePath,
+          status: "failed",
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw new SetupGithubError(
+          "github_workflow_write_failed",
+          `Unable to write ${relativePath}.`,
+          500,
+          result
+        );
+      }
+    }
+  } catch (error) {
+    if (error instanceof SetupGithubError) throw error;
+    throw new SetupGithubError(
+      "github_workflow_write_failed",
+      "Unable to create .github/workflows.",
+      500,
+      result
+    );
+  }
+  return result;
+}
+__name(setupGithub, "setupGithub");
+async function updateGitignore(gitRepoRoot, fileOps = nodeFileOps) {
+  try {
+    const existingContent = await fileOps.readTextFile(
+      gitRepoRoot,
+      ".gitignore"
+    );
+    if (existingContent === void 0) {
+      const content = GITIGNORE_ENTRIES.join("\n") + "\n";
+      await fileOps.writeTextFile(gitRepoRoot, ".gitignore", content);
+      return {
+        path: ".gitignore",
+        status: "created",
+        added: [...GITIGNORE_ENTRIES]
+      };
+    }
+    const missingEntries = GITIGNORE_ENTRIES.filter(
+      (entry) => !existingContent.split(/\r?\n/).some((line) => line.split("#")[0].trim() === entry)
+    );
+    if (missingEntries.length === 0) {
+      return { path: ".gitignore", status: "unchanged" };
+    }
+    const nextContent = existingContent + "\n" + missingEntries.join("\n") + "\n";
+    await fileOps.writeTextFile(gitRepoRoot, ".gitignore", nextContent);
+    return {
+      path: ".gitignore",
+      status: "updated",
+      added: missingEntries
+    };
+  } catch (error) {
+    debugLogger2.debug("Failed to update .gitignore:", error);
+    return {
+      path: ".gitignore",
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(updateGitignore, "updateGitignore");
+async function downloadWorkflows(options) {
+  const internalAbort = new AbortController();
+  try {
+    const dispatcher = options.proxy ? new import_undici2.ProxyAgent(options.proxy) : void 0;
+    return await Promise.all(
+      GITHUB_WORKFLOW_PATHS.map(async (workflow) => {
+        const endpoint = `https://raw.githubusercontent.com/QwenLM/qwen-code-action/refs/tags/${options.releaseTag}/examples/workflows/${workflow}`;
+        const response = await options.fetchImpl(endpoint, {
+          method: "GET",
+          dispatcher,
+          signal: AbortSignal.any([
+            AbortSignal.timeout(3e4),
+            internalAbort.signal,
+            ...options.abortSignal ? [options.abortSignal] : []
+          ])
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Invalid response code downloading ${endpoint}: ${response.status} - ${response.statusText}`
+          );
+        }
+        return {
+          sourcePath: workflow,
+          content: await readResponseTextWithLimit(response, workflow)
+        };
+      })
+    );
+  } catch (error) {
+    internalAbort.abort();
+    const message = error instanceof Error ? error.message : String(error);
+    debugLogger2.debug("Failed to download qwen-code-action workflows:", error);
+    throw new SetupGithubError(
+      "github_workflow_download_failed",
+      `Unable to download qwen-code-action workflows from GitHub. ${message}`,
+      502
+    );
+  }
+}
+__name(downloadWorkflows, "downloadWorkflows");
+async function readResponseTextWithLimit(response, sourcePath) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength !== null) {
+    const parsedLength = Number(contentLength);
+    if (Number.isFinite(parsedLength) && parsedLength > MAX_WORKFLOW_DOWNLOAD_BYTES) {
+      throw new Error(
+        `${sourcePath} exceeds download limit of ${MAX_WORKFLOW_DOWNLOAD_BYTES} bytes`
       );
-      cumulative.apiTimeMs = addFinite(cumulative.apiTimeMs, durationMs);
     }
-    const meta = typeof durationMs === "number" ? { usage, durationMs, ...subagentMeta } : { usage, ...subagentMeta };
-    await this.sendUpdate({
-      sessionUpdate: "agent_message_chunk",
-      content: { type: "text", text },
-      _meta: meta
-    });
   }
-  /**
-   * Emits a message chunk based on role and thought flag.
-   * This is the unified method that handles all message types.
-   *
-   * @param text - The message text content
-   * @param role - Whether this is a user or assistant message
-   * @param isThought - Whether this is an assistant thought (only applies to assistant role)
-   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
-   */
-  async emitMessage(text, role, isThought = false, timestamp, subagentMeta) {
-    if (role === "user") {
-      return this.emitUserMessage(text, timestamp);
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      totalBytes += value.byteLength;
+      if (totalBytes > MAX_WORKFLOW_DOWNLOAD_BYTES) {
+        await reader.cancel().catch(() => {
+        });
+        throw new Error(
+          `${sourcePath} exceeds download limit of ${MAX_WORKFLOW_DOWNLOAD_BYTES} bytes`
+        );
+      }
+      chunks.push(value);
     }
-    return isThought ? this.emitAgentThought(text, timestamp, subagentMeta) : this.emitAgentMessage(text, timestamp, subagentMeta);
+  } finally {
+    reader.releaseLock();
   }
-  buildChunkMeta(epochMs, subagentMeta) {
-    const meta = {
-      ...subagentMeta?.parentToolCallId ? { parentToolCallId: subagentMeta.parentToolCallId } : {},
-      ...subagentMeta?.subagentType ? { subagentType: subagentMeta.subagentType } : {},
-      ...epochMs != null ? { timestamp: epochMs } : {}
-    };
-    return Object.keys(meta).length > 0 ? meta : void 0;
+  const body = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
   }
-};
+  return new TextDecoder().decode(body);
+}
+__name(readResponseTextWithLimit, "readResponseTextWithLimit");
+async function resolveSecretsUrl(cwd) {
+  try {
+    const repoInfo = await getGitHubRepoInfoAsync({ cwd });
+    return `https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`;
+  } catch {
+    return void 0;
+  }
+}
+__name(resolveSecretsUrl, "resolveSecretsUrl");
+async function realpathOrResolve(input) {
+  try {
+    return await fsp.realpath(input);
+  } catch {
+    return path.resolve(input);
+  }
+}
+__name(realpathOrResolve, "realpathOrResolve");
 
-// packages/cli/src/acp-integration/session/emitters/ToolCallEmitter.ts
+// packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
 init_esbuild_shims();
 
-// packages/cli/src/acp-integration/session/emitters/PlanEmitter.ts
+// packages/cli/src/acp-integration/session/emitters/base-emitter.ts
 init_esbuild_shims();
-var PlanEmitter = class extends BaseEmitter {
-  static {
-    __name(this, "PlanEmitter");
+var BaseEmitter = class {
+  constructor(ctx) {
+    this.ctx = ctx;
   }
-  /**
-   * Emits a plan update with the given todo items.
-   *
-   * @param todos - Array of todo items to send as plan entries
-   */
-  async emitPlan(todos) {
-    const entries = todos.map((todo) => ({
-      content: todo.content,
-      priority: "medium",
-      // Default priority since todos don't have priority
-      status: todo.status
-    }));
-    const cumulative = this.ctx.cumulativeUsage;
-    await this.sendUpdate({
-      sessionUpdate: "plan",
-      entries,
-      ...cumulative ? { _meta: { stats: { ...cumulative } } } : {}
-    });
+  static {
+    __name(this, "BaseEmitter");
   }
   /**
-   * Extracts todos from tool result display or args.
-   * Tries multiple sources in priority order:
-   * 1. Result display object with type 'todo_list'
-   * 2. Result display as JSON string
-   * 3. Args with 'todos' array
-   *
-   * @param resultDisplay - The tool result display (object, string, or undefined)
-   * @param args - The tool call arguments (fallback source)
-   * @returns Array of todos if found, null otherwise
+   * Converts an ISO timestamp string or epoch ms to epoch ms number.
+   * Returns undefined if the input is not a valid timestamp.
    */
-  extractTodos(resultDisplay, args) {
-    const fromDisplay = this.extractFromResultDisplay(resultDisplay);
-    if (fromDisplay) return fromDisplay;
-    if (args && Array.isArray(args["todos"])) {
-      return args["todos"];
+  static toEpochMs(ts) {
+    if (typeof ts === "number") {
+      return Number.isFinite(ts) ? ts : void 0;
     }
-    return null;
+    if (typeof ts === "string") {
+      const ms = new Date(ts).getTime();
+      return Number.isFinite(ms) ? ms : void 0;
+    }
+    return void 0;
   }
   /**
-   * Extracts todos from a result display value.
-   * Handles both object and JSON string formats.
+   * Sends a session update to the ACP client.
+   * If a message rewriter is configured, updates pass through it first
+   * (original messages are sent as-is, rewritten versions are appended).
    */
-  extractFromResultDisplay(resultDisplay) {
-    if (!resultDisplay) return null;
-    if (typeof resultDisplay === "object") {
-      const obj = resultDisplay;
-      if (obj["type"] === "todo_list" && Array.isArray(obj["todos"])) {
-        return obj["todos"];
-      }
-    }
-    if (typeof resultDisplay === "string") {
-      try {
-        const parsed = JSON.parse(resultDisplay);
-        if (parsed?.["type"] === "todo_list" && Array.isArray(parsed["todos"])) {
-          return parsed["todos"];
-        }
-      } catch {
-      }
+  async sendUpdate(update) {
+    if (this.ctx.messageRewriter) {
+      return this.ctx.messageRewriter.interceptUpdate(update);
     }
-    return null;
+    return this.ctx.sendUpdate(update);
   }
-};
-
-// packages/cli/src/utils/truncatedDiffPreview.ts
-init_esbuild_shims();
-function buildTruncatedDiffPreviewText(display) {
-  const fileName = typeof display["fileName"] === "string" ? display["fileName"] : "the edited file";
-  const fileDiffLength = typeof display["fileDiffLength"] === "number" ? ` Original fileDiff length: ${display["fileDiffLength"]} chars.` : "";
-  if (display["fileDiffTruncated"] === true) {
-    return `Full diff omitted from saved session history for ${fileName}.${fileDiffLength}`;
+  /**
+   * Gets the session ID.
+   */
+  get sessionId() {
+    return this.ctx.sessionId;
   }
-  return `Saved session preview only for ${fileName}; full original and new file contents are unavailable.`;
-}
-__name(buildTruncatedDiffPreviewText, "buildTruncatedDiffPreviewText");
-
-// packages/cli/src/acp-integration/session/emitters/ToolCallEmitter.ts
-var KIND_MAP = {
-  ["read" /* Read */]: "read",
-  ["edit" /* Edit */]: "edit",
-  ["delete" /* Delete */]: "delete",
-  ["move" /* Move */]: "move",
-  ["search" /* Search */]: "search",
-  ["execute" /* Execute */]: "execute",
-  ["think" /* Think */]: "think",
-  ["fetch" /* Fetch */]: "fetch",
-  // ACP defines no 'agent' ToolKind (verified through @agentclientprotocol/sdk
-  // 0.25.1). The daemon's ClientSideConnection Zod-validates every session/update
-  // and session/request_permission from the `qwen --acp` child before fanning out
-  // to SSE clients, so emitting 'agent' is rejected at that hop and the frame is
-  // dropped. Map the internal Kind.Agent to 'other' on the wire to stay
-  // protocol-valid; dedicated agent UI is delivered out-of-band (via _meta.toolName)
-  // in a follow-up rather than via a kind the protocol can't carry.
-  ["agent" /* Agent */]: "other",
-  ["other" /* Other */]: "other"
 };
-var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
+
+// packages/cli/src/acp-integration/session/emitters/MessageEmitter.ts
+var MessageEmitter = class extends BaseEmitter {
   static {
-    __name(this, "ToolCallEmitter");
-  }
-  planEmitter;
-  constructor(ctx) {
-    super(ctx);
-    this.planEmitter = new PlanEmitter(ctx);
+    __name(this, "MessageEmitter");
   }
   /**
-   * Emits a tool call start event.
+   * Emits a StopHookLoop event when Stop hooks create a loop.
+   * This informs the client that Stop hooks have been executed multiple times.
    *
-   * @param params - Tool call start parameters
-   * @returns true if event was emitted, false if skipped (e.g., TodoWriteTool)
+   * @param iterationCount - The current iteration count
+   * @param reasons - Array of reasons from each Stop hook execution
+   * @param stopHookCount - Number of Stop hooks that were executed
    */
-  async emitStart(params) {
-    if (this.isTodoWriteTool(params.toolName)) {
-      return false;
-    }
-    const { title, locations, kind } = this.resolveToolMetadata(
-      params.toolName,
-      params.args
-    );
-    const provenance = _ToolCallEmitter.resolveToolProvenance(
-      params.toolName,
-      params.subagentMeta
-    );
+  async emitStopHookLoop(iterationCount, reasons, stopHookCount) {
+    const activeGoal = getActiveGoal(this.sessionId);
     await this.sendUpdate({
-      sessionUpdate: "tool_call",
-      toolCallId: params.callId,
-      status: params.status || "pending",
-      title,
-      content: [],
-      locations,
-      kind,
-      rawInput: params.args ?? {},
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: "" },
       _meta: {
-        toolName: params.toolName,
-        ...params.subagentMeta,
-        provenance: provenance.provenance,
-        ...provenance.serverId ? { serverId: provenance.serverId } : {},
-        ...BaseEmitter.toEpochMs(params.timestamp) != null && {
-          timestamp: BaseEmitter.toEpochMs(params.timestamp)
+        stopHookLoop: {
+          iterationCount,
+          reasons,
+          stopHookCount,
+          ...activeGoal ? {
+            goal: {
+              condition: activeGoal.condition,
+              iterations: activeGoal.iterations,
+              setAt: activeGoal.setAt,
+              lastReason: activeGoal.lastReason
+            }
+          } : {}
         }
       }
     });
-    return true;
   }
-  /**
-   * Emits a tool call result event.
-   * Handles TodoWriteTool specially by routing to plan updates.
-   *
-   * @param params - Tool call result parameters
-   */
-  async emitResult(params) {
-    if (this.isTodoWriteTool(params.toolName)) {
-      const todos = this.planEmitter.extractTodos(
-        params.resultDisplay,
-        params.args
-      );
-      if (todos && todos.length > 0) {
-        await this.planEmitter.emitPlan(todos);
-      } else if (params.args && Array.isArray(params.args["todos"])) {
-        await this.planEmitter.emitPlan([]);
+  async emitGoalTerminal(event) {
+    await this.sendUpdate({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: "" },
+      _meta: {
+        goalTerminal: event
       }
-      return;
-    }
-    let contentArray = [];
-    const diffContent = this.extractDiffContent(params.resultDisplay);
-    if (diffContent) {
-      contentArray = [diffContent];
-    } else if (params.error) {
-      contentArray = [
-        {
-          type: "content",
-          content: { type: "text", text: params.error.message }
-        }
-      ];
-    } else {
-      contentArray = this.transformPartsToToolCallContent(params.message);
-    }
-    const provenance = _ToolCallEmitter.resolveToolProvenance(
-      params.toolName,
-      params.subagentMeta
-    );
-    const update = {
-      sessionUpdate: "tool_call_update",
-      toolCallId: params.callId,
-      status: params.success ? "completed" : "failed",
-      content: contentArray,
+    });
+  }
+  async emitGoalStatus(status) {
+    await this.sendUpdate({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: "" },
       _meta: {
-        toolName: params.toolName,
-        ...params.subagentMeta,
-        provenance: provenance.provenance,
-        ...provenance.serverId ? { serverId: provenance.serverId } : {},
-        ...BaseEmitter.toEpochMs(params.timestamp) != null && {
-          timestamp: BaseEmitter.toEpochMs(params.timestamp)
-        },
-        ...params.artifacts && params.artifacts.length > 0 ? { artifacts: params.artifacts } : {}
+        goalStatus: status
       }
-    };
-    if (params.resultDisplay !== void 0 && !this.isTruncatedSessionDiffDisplay(params.resultDisplay)) {
-      update["rawOutput"] = params.resultDisplay;
-    }
-    await this.sendUpdate(update);
+    });
   }
   /**
-   * Emits a tool call error event.
-   * Use this for explicit error handling when not using emitResult.
+   * Emits a user message chunk.
    *
-   * @param callId - The tool call ID
-   * @param toolName - The tool name
-   * @param error - The error that occurred
-   * @param subagentMeta - Optional subagent metadata
+   * @param text - The user message text content
+   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
    */
-  async emitError(callId, toolName, error, subagentMeta) {
-    const provenance = _ToolCallEmitter.resolveToolProvenance(
-      toolName,
-      subagentMeta
-    );
+  async emitUserMessage(text, timestamp, options = {}) {
+    const epochMs = BaseEmitter.toEpochMs(timestamp);
+    const _meta = {
+      ...epochMs != null ? { timestamp: epochMs } : {},
+      ...options.source ? { source: options.source } : {}
+    };
     await this.sendUpdate({
-      sessionUpdate: "tool_call_update",
-      toolCallId: callId,
-      status: "failed",
-      content: [
-        { type: "content", content: { type: "text", text: error.message } }
-      ],
-      _meta: {
-        toolName,
-        ...subagentMeta,
-        provenance: provenance.provenance,
-        ...provenance.serverId ? { serverId: provenance.serverId } : {}
-      }
+      sessionUpdate: "user_message_chunk",
+      content: { type: "text", text },
+      ...Object.keys(_meta).length > 0 ? { _meta } : {}
     });
   }
   /**
-   * Resolve a tool's provenance for UI dispatch on tool_call events.
-   * The SDK reads `_meta.
-   * provenance` + `_meta.serverId` to render builtin / MCP-server-badge /
-   * subagent-block differently. Without this stamping, the SDK falls
-   * back to string-matching the toolName which can't reliably
-   * distinguish builtin from subagent.
-   *
-   * Resolution rules:
-   *   - `subagentMeta` present → `'subagent'` (a Task tool / Codex
-   *     subagent / etc. wrapping its own tool calls)
-   *   - toolName matches `mcp__<server>__<tool>` → `'mcp'` with
-   *     `serverId: <server>`. Naming convention from
-   *     `packages/core/src/tools/mcp-tool.ts` in the
-   *     `@qwen-code/qwen-code-core` package — mirrors the SDK's same
-   *     heuristic fallback so SDK consumers stay consistent with
-   *     daemon classification.
-   *   - everything else → `'builtin'`
+   * Emits an agent thought chunk.
    *
-   * Static + pure so it can be unit-tested without an emitter
-   * instance. Exported via `ToolCallEmitter.resolveToolProvenance`.
+   * @param text - The thought text content
+   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
    */
-  static resolveToolProvenance(toolName, subagentMeta) {
-    if (subagentMeta !== void 0) {
-      return { provenance: "subagent" };
-    }
-    if (toolName.startsWith("mcp__")) {
-      const parts = toolName.split("__");
-      if (parts.length >= 3 && parts[1] && parts[1].length > 0) {
-        return { provenance: "mcp", serverId: parts[1] };
-      }
-    }
-    return { provenance: "builtin" };
+  async emitAgentThought(text, timestamp, subagentMeta) {
+    const _meta = this.buildChunkMeta(
+      BaseEmitter.toEpochMs(timestamp),
+      subagentMeta
+    );
+    await this.sendUpdate({
+      sessionUpdate: "agent_thought_chunk",
+      content: { type: "text", text },
+      ..._meta ? { _meta } : {}
+    });
   }
-  // ==================== Public Utilities ====================
   /**
-   * Checks if a tool name is the TodoWriteTool.
-   * Exposed for external use in components that need to check this.
+   * Emits an agent message chunk.
+   *
+   * @param text - The agent message text content
+   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
    */
-  isTodoWriteTool(toolName) {
-    return toolName === ToolNames.TODO_WRITE;
+  async emitAgentMessage(text, timestamp, subagentMeta) {
+    const _meta = this.buildChunkMeta(
+      BaseEmitter.toEpochMs(timestamp),
+      subagentMeta
+    );
+    await this.sendUpdate({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text },
+      ..._meta ? { _meta } : {}
+    });
   }
-  /**
-   * Checks if a tool name is the ExitPlanModeTool.
-   */
-  isExitPlanModeTool(toolName) {
-    return toolName === ToolNames.EXIT_PLAN_MODE;
+  async emitSlashCommandOutput(text, timestamp) {
+    const epochMs = BaseEmitter.toEpochMs(timestamp);
+    await this.sendUpdate({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text },
+      _meta: {
+        source: "slash_command",
+        ...epochMs != null ? { timestamp: epochMs } : {}
+      }
+    });
   }
   /**
-   * Checks if a tool name is the EnterPlanModeTool.
+   * Emits usage metadata.
    */
-  isEnterPlanModeTool(toolName) {
-    return toolName === ToolNames.ENTER_PLAN_MODE;
+  async emitUsageMetadata(usageMetadata, text = "", durationMs, subagentMeta) {
+    const usage = {
+      inputTokens: usageMetadata.promptTokenCount ?? 0,
+      outputTokens: usageMetadata.candidatesTokenCount ?? 0,
+      totalTokens: usageMetadata.totalTokenCount ?? 0,
+      thoughtTokens: usageMetadata.thoughtsTokenCount,
+      cachedReadTokens: usageMetadata.cachedContentTokenCount
+    };
+    const cumulative = this.ctx.cumulativeUsage;
+    if (cumulative) {
+      const addFinite = /* @__PURE__ */ __name((total, value) => typeof value === "number" && Number.isFinite(value) ? total + value : total, "addFinite");
+      cumulative.promptTokens = addFinite(
+        cumulative.promptTokens,
+        usage.inputTokens
+      );
+      cumulative.candidateTokens = addFinite(
+        cumulative.candidateTokens,
+        usage.outputTokens
+      );
+      cumulative.cachedTokens = addFinite(
+        cumulative.cachedTokens,
+        usage.cachedReadTokens
+      );
+      cumulative.apiTimeMs = addFinite(cumulative.apiTimeMs, durationMs);
+    }
+    let meta;
+    if (typeof durationMs === "number") {
+      const activity = apiActivityTracker.drain();
+      meta = {
+        usage,
+        durationMs,
+        ...activity.errors > 0 ? { apiErrors: activity.errors } : {},
+        ...activity.retries > 0 ? { apiRetries: activity.retries } : {},
+        ...subagentMeta
+      };
+    } else {
+      meta = { usage, ...subagentMeta };
+    }
+    await this.sendUpdate({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text },
+      _meta: meta
+    });
   }
   /**
-   * Resolves tool metadata from the registry.
-   * Falls back to defaults if tool not found or build fails.
+   * Emits a message chunk based on role and thought flag.
+   * This is the unified method that handles all message types.
    *
-   * @param toolName - Name of the tool
-   * @param args - Tool call arguments (used to build invocation)
+   * @param text - The message text content
+   * @param role - Whether this is a user or assistant message
+   * @param isThought - Whether this is an assistant thought (only applies to assistant role)
+   * @param timestamp - Optional server-side timestamp (ISO string or ms) for message ordering
    */
-  resolveToolMetadata(toolName, args) {
-    const toolRegistry = this.config.getToolRegistry();
-    const tool = toolRegistry.getTool(toolName);
-    let title = tool?.displayName ?? toolName;
-    let locations = [];
-    let kind = "other";
-    if (tool && args) {
-      try {
-        const invocation = tool.build(args);
-        title = `${title}: ${invocation.getDescription()}`;
-        locations = invocation.toolLocations().map((loc) => ({
-          path: loc.path,
-          line: loc.line ?? null
-        }));
-        kind = this.mapToolKind(tool.kind, toolName);
-      } catch {
-        if (typeof args["description"] === "string") {
-          title = `${title}: ${args["description"]}`;
-        }
-        if (tool.kind) {
-          kind = this.mapToolKind(tool.kind, toolName);
-        }
-      }
+  async emitMessage(text, role, isThought = false, timestamp, subagentMeta) {
+    if (role === "user") {
+      return this.emitUserMessage(text, timestamp);
     }
-    return { title, locations, kind };
+    return isThought ? this.emitAgentThought(text, timestamp, subagentMeta) : this.emitAgentMessage(text, timestamp, subagentMeta);
+  }
+  buildChunkMeta(epochMs, subagentMeta) {
+    const meta = {
+      ...subagentMeta?.parentToolCallId ? { parentToolCallId: subagentMeta.parentToolCallId } : {},
+      ...subagentMeta?.subagentType ? { subagentType: subagentMeta.subagentType } : {},
+      ...epochMs != null ? { timestamp: epochMs } : {}
+    };
+    return Object.keys(meta).length > 0 ? meta : void 0;
+  }
+};
+
+// packages/cli/src/acp-integration/session/emitters/PlanEmitter.ts
+init_esbuild_shims();
+var PlanEmitter = class extends BaseEmitter {
+  static {
+    __name(this, "PlanEmitter");
   }
   /**
-   * Maps core Tool Kind enum to ACP ToolKind string literals.
+   * Emits a plan update with the given todo items.
    *
-   * @param kind - The core Kind enum value
-   * @param toolName - Optional tool name to handle special cases like exit_plan_mode
+   * @param todos - Array of todo items to send as plan entries
    */
-  mapToolKind(kind, toolName) {
-    if (toolName && (this.isExitPlanModeTool(toolName) || this.isEnterPlanModeTool(toolName))) {
-      return "switch_mode";
-    }
-    return KIND_MAP[kind] ?? "other";
+  async emitPlan(todos) {
+    const entries = todos.map((todo) => ({
+      content: todo.content,
+      priority: "medium",
+      // Default priority since todos don't have priority
+      status: todo.status
+    }));
+    const cumulative = this.ctx.cumulativeUsage;
+    await this.sendUpdate({
+      sessionUpdate: "plan",
+      entries,
+      ...cumulative ? { _meta: { stats: { ...cumulative } } } : {}
+    });
   }
-  // ==================== Private Helpers ====================
   /**
-   * Extracts diff content from resultDisplay if it's a diff type (edit tool result).
-   * Returns null if not a diff.
+   * Extracts todos from tool result display or args.
+   * Tries multiple sources in priority order:
+   * 1. Result display object with type 'todo_list'
+   * 2. Result display as JSON string
+   * 3. Args with 'todos' array
+   *
+   * @param resultDisplay - The tool result display (object, string, or undefined)
+   * @param args - The tool call arguments (fallback source)
+   * @returns Array of todos if found, null otherwise
    */
-  extractDiffContent(resultDisplay) {
-    if (!resultDisplay || typeof resultDisplay !== "object") return null;
-    const obj = resultDisplay;
-    if ("fileName" in obj && "newContent" in obj) {
-      if (this.isTruncatedSessionDiffDisplay(resultDisplay)) {
-        return {
-          type: "content",
-          content: {
-            type: "text",
-            text: buildTruncatedDiffPreviewText(obj)
-          }
-        };
-      }
-      return {
-        type: "diff",
-        path: obj["fileName"],
-        oldText: obj["originalContent"] ?? "",
-        newText: obj["newContent"]
-      };
+  extractTodos(resultDisplay, args) {
+    const fromDisplay = this.extractFromResultDisplay(resultDisplay);
+    if (fromDisplay) return fromDisplay;
+    if (args && Array.isArray(args["todos"])) {
+      return args["todos"];
     }
     return null;
   }
-  isTruncatedSessionDiffDisplay(resultDisplay) {
-    if (!resultDisplay || typeof resultDisplay !== "object") return false;
-    const obj = resultDisplay;
-    return obj["truncatedForSession"] === true && "fileName" in obj && "newContent" in obj;
-  }
   /**
-   * Transforms Part[] to ToolCallContent[].
-   * Extracts text from functionResponse parts and text parts.
+   * Extracts todos from a result display value.
+   * Handles both object and JSON string formats.
    */
-  transformPartsToToolCallContent(parts) {
-    const result = [];
-    for (const part of parts) {
-      if ("text" in part && part.text) {
-        result.push({
-          type: "content",
-          content: { type: "text", text: part.text }
-        });
+  extractFromResultDisplay(resultDisplay) {
+    if (!resultDisplay) return null;
+    if (typeof resultDisplay === "object") {
+      const obj = resultDisplay;
+      if (obj["type"] === "todo_list" && Array.isArray(obj["todos"])) {
+        return obj["todos"];
       }
-      if ("functionResponse" in part && part.functionResponse) {
-        try {
-          const resp = part.functionResponse.response;
-          const outputField = resp["output"];
-          const errorField = resp["error"];
-          const responseText = typeof outputField === "string" ? outputField : typeof errorField === "string" ? errorField : JSON.stringify(resp);
-          result.push({
-            type: "content",
-            content: { type: "text", text: responseText }
-          });
-        } catch {
+    }
+    if (typeof resultDisplay === "string") {
+      try {
+        const parsed = JSON.parse(resultDisplay);
+        if (parsed?.["type"] === "todo_list" && Array.isArray(parsed["todos"])) {
+          return parsed["todos"];
         }
+      } catch {
       }
     }
-    return result;
+    return null;
   }
 };
 
-// packages/cli/src/utils/chat-record-tool-call-id.ts
+// packages/cli/src/acp-integration/session/emitters/tool-call-emitter.ts
 init_esbuild_shims();
-function getToolResultCallId(record) {
-  return getExplicitToolResultCallId(record) ?? record.uuid;
-}
-__name(getToolResultCallId, "getToolResultCallId");
-function getExplicitToolResultCallId(record) {
-  const resultCallId = record.toolCallResult?.callId;
-  if (typeof resultCallId === "string" && resultCallId.length > 0) {
-    return resultCallId;
-  }
-  return extractFunctionResponseId(record);
+
+// packages/cli/src/acp-integration/session/types.ts
+init_esbuild_shims();
+function hasFullSessionContext(context) {
+  return "config" in context;
 }
-__name(getExplicitToolResultCallId, "getExplicitToolResultCallId");
-function extractFunctionResponseId(record) {
-  if (!record.message?.parts) {
-    return void 0;
-  }
-  for (const part of record.message.parts) {
-    const id = "functionResponse" in part ? part.functionResponse?.id : void 0;
-    if (typeof id === "string" && id.length > 0) {
-      return id;
-    }
+__name(hasFullSessionContext, "hasFullSessionContext");
+
+// packages/cli/src/utils/truncatedDiffPreview.ts
+init_esbuild_shims();
+function buildTruncatedDiffPreviewText(display) {
+  const fileName = typeof display["fileName"] === "string" ? display["fileName"] : "the edited file";
+  const fileDiffLength = typeof display["fileDiffLength"] === "number" ? ` Original fileDiff length: ${display["fileDiffLength"]} chars.` : "";
+  if (display["fileDiffTruncated"] === true) {
+    return `Full diff omitted from saved session history for ${fileName}.${fileDiffLength}`;
   }
-  return void 0;
+  return `Saved session preview only for ${fileName}; full original and new file contents are unavailable.`;
 }
-__name(extractFunctionResponseId, "extractFunctionResponseId");
+__name(buildTruncatedDiffPreviewText, "buildTruncatedDiffPreviewText");
 
-// packages/cli/src/acp-integration/session/HistoryReplayer.ts
-var MISSING_TOOL_RESULT_MESSAGE = "Tool result missing from saved history; the previous run likely ended before this tool completed.";
-var HistoryReplayer = class {
+// packages/cli/src/acp-integration/session/emitters/tool-call-emitter.ts
+var KIND_MAP = {
+  ["read" /* Read */]: "read",
+  ["edit" /* Edit */]: "edit",
+  ["delete" /* Delete */]: "delete",
+  ["move" /* Move */]: "move",
+  ["search" /* Search */]: "search",
+  ["execute" /* Execute */]: "execute",
+  ["think" /* Think */]: "think",
+  ["fetch" /* Fetch */]: "fetch",
+  // ACP defines no 'agent' ToolKind (verified through @agentclientprotocol/sdk
+  // 0.25.1). The daemon's ClientSideConnection Zod-validates every session/update
+  // and session/request_permission from the `qwen --acp` child before fanning out
+  // to SSE clients, so emitting 'agent' is rejected at that hop and the frame is
+  // dropped. Map the internal Kind.Agent to 'other' on the wire to stay
+  // protocol-valid; dedicated agent UI is delivered out-of-band (via _meta.toolName)
+  // in a follow-up rather than via a kind the protocol can't carry.
+  ["agent" /* Agent */]: "other",
+  ["other" /* Other */]: "other"
+};
+var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
   static {
-    __name(this, "HistoryReplayer");
+    __name(this, "ToolCallEmitter");
   }
-  ctx;
-  messageEmitter;
-  toolCallEmitter;
-  pendingReplayToolCalls = /* @__PURE__ */ new Map();
+  planEmitter;
+  preparedCallIds = /* @__PURE__ */ new Set();
   constructor(ctx) {
-    this.ctx = ctx;
-    this.messageEmitter = new MessageEmitter(ctx);
-    this.toolCallEmitter = new ToolCallEmitter(ctx);
+    super(ctx);
+    this.planEmitter = new PlanEmitter(ctx);
   }
   /**
-   * Replays all chat records from a loaded session.
+   * Emits a tool call start event.
    *
-   * @param records - Array of chat records to replay
-   * @param gaps - Optional detected history gaps; a visible notice is emitted
-   *   immediately before each gap's child record so the user sees that an
-   *   earlier segment was lost rather than assuming the halves are contiguous.
+   * @param params - Tool call start parameters
+   * @returns true if event was emitted, false if skipped (e.g., TodoWriteTool)
    */
-  async replay(records, gaps) {
-    try {
-      await this.replayPage(records, { finalizeDangling: true, gaps });
-    } finally {
-      this.pendingReplayToolCalls.clear();
-      this.setActiveRecordId(null);
+  async emitStart(params) {
+    if (this.isTodoWriteTool(params.toolName)) {
+      return false;
     }
-  }
-  async replayPage(records, options = {}) {
-    this.pendingReplayToolCalls.clear();
-    for (const pending of options.pendingToolCalls ?? []) {
-      this.pendingReplayToolCalls.set(pending.callId, pending);
+    if (params.phase === "preparing" && this.preparedCallIds.has(params.callId)) {
+      return false;
     }
-    const gapByChildUuid = indexGapsByChild(options.gaps);
-    let replayError;
-    try {
-      for (const record of records) {
-        const gap = gapByChildUuid.get(record.uuid);
-        if (gap) {
-          await this.emitHistoryGapNotice(gap, record.timestamp);
+    const { title, locations, kind } = this.resolveToolMetadata(
+      params.toolName,
+      params.args
+    );
+    const provenance = _ToolCallEmitter.resolveToolProvenance(
+      params.toolName,
+      params.subagentMeta
+    );
+    const updatesPreparedCall = params.phase !== "preparing" && this.preparedCallIds.delete(params.callId);
+    const update = {
+      toolCallId: params.callId,
+      status: params.status || "pending",
+      title,
+      content: [],
+      locations,
+      kind,
+      rawInput: params.args ?? {},
+      _meta: {
+        toolName: params.toolName,
+        ...params.phase ? { phase: params.phase } : {},
+        ...params.subagentMeta,
+        provenance: provenance.provenance,
+        ...provenance.serverId ? { serverId: provenance.serverId } : {},
+        ...BaseEmitter.toEpochMs(params.timestamp) != null && {
+          timestamp: BaseEmitter.toEpochMs(params.timestamp)
         }
-        await this.replayRecord(record);
-      }
-    } catch (error) {
-      replayError = error;
-    }
-    let danglingError;
-    if (options.finalizeDangling === true) {
-      try {
-        await this.failDanglingToolCalls();
-      } catch (error) {
-        danglingError = error;
       }
-    }
-    const state = {
-      pendingToolCalls: options.finalizeDangling === true ? [] : Array.from(this.pendingReplayToolCalls.values())
     };
-    this.setActiveRecordId(null);
-    if (replayError && danglingError) {
-      throw new AggregateError(
-        [replayError, danglingError],
-        "Replay and dangling-cleanup both failed"
-      );
-    }
-    if (replayError) {
-      throw replayError;
-    }
-    if (danglingError) {
-      throw danglingError;
+    await this.sendUpdate(
+      updatesPreparedCall ? { sessionUpdate: "tool_call_update", ...update } : { sessionUpdate: "tool_call", ...update }
+    );
+    if (params.phase === "preparing") {
+      this.preparedCallIds.add(params.callId);
     }
-    return state;
+    return true;
   }
-  getPendingToolCalls() {
-    return Array.from(this.pendingReplayToolCalls.values());
+  /**
+   * Emits a terminal frame when a prepared tool call is discarded before
+   * execution. TodoWrite remains represented exclusively by plan updates.
+   *
+   * @param callId - ID of the prepared tool call
+   * @param toolName - Name of the prepared tool
+   */
+  async emitPreparationDiscarded(callId, toolName) {
+    if (this.isTodoWriteTool(toolName)) return;
+    this.preparedCallIds.delete(callId);
+    const provenance = _ToolCallEmitter.resolveToolProvenance(toolName);
+    await this.sendUpdate({
+      sessionUpdate: "tool_call_update",
+      toolCallId: callId,
+      status: "failed",
+      content: [],
+      _meta: {
+        toolName,
+        phase: "preparing",
+        preparationDiscarded: true,
+        provenance: provenance.provenance,
+        ...provenance.serverId ? { serverId: provenance.serverId } : {}
+      }
+    });
   }
   /**
-   * Replays a single chat record.
+   * Emits a tool call result event.
+   * Handles TodoWriteTool specially by routing to plan updates.
+   *
+   * @param params - Tool call result parameters
    */
-  async replayRecord(record) {
-    this.setActiveRecordId(record.uuid, record.timestamp);
-    try {
-      switch (record.type) {
-        case "user":
-          if (record.subtype === "notification" || record.subtype === "cron") {
-            const displayText = record.systemPayload?.displayText;
-            if (displayText) {
-              await this.messageEmitter.emitUserMessage(
-                displayText,
-                record.timestamp,
-                record.subtype === "cron" ? { source: "cron" } : void 0
-              );
-            }
-            break;
-          }
-          if (record.subtype === "mid_turn_user_message") {
-            const displayText = record.systemPayload?.displayText;
-            if (displayText) {
-              await this.messageEmitter.emitUserMessage(
-                displayText,
-                record.timestamp
-              );
-            } else if (record.message) {
-              await this.replayContent(
-                record.message,
-                "user",
-                record.timestamp,
-                record.uuid
-              );
-            }
-            break;
-          }
-          if (record.message) {
-            await this.replayContent(
-              record.message,
-              "user",
-              record.timestamp,
-              record.uuid
-            );
-          }
-          break;
-        case "assistant":
-          if (record.message) {
-            await this.replayContent(
-              record.message,
-              "assistant",
-              record.timestamp,
-              record.uuid
-            );
-          }
-          if (record.usageMetadata) {
-            await this.replayUsageMetadata(record.usageMetadata);
-          }
-          break;
-        case "tool_result":
-          await this.replayToolResult(record);
-          break;
-        case "system":
-          if (record.subtype === "slash_command") {
-            await this.replaySlashCommandResult(record);
-          }
-          break;
-        default:
-          break;
+  async emitResult(params) {
+    if (this.isTodoWriteTool(params.toolName)) {
+      const todos = this.planEmitter.extractTodos(
+        params.resultDisplay,
+        params.args
+      );
+      if (todos && todos.length > 0) {
+        await this.planEmitter.emitPlan(todos);
+      } else if (params.args && Array.isArray(params.args["todos"])) {
+        await this.planEmitter.emitPlan([]);
       }
-    } finally {
-      this.setActiveRecordId(null);
+      return;
+    }
+    this.preparedCallIds.delete(params.callId);
+    let contentArray = [];
+    const diffContent = this.extractDiffContent(params.resultDisplay);
+    if (diffContent) {
+      contentArray = [diffContent];
+    } else if (params.error) {
+      contentArray = [
+        {
+          type: "content",
+          content: { type: "text", text: params.error.message }
+        }
+      ];
+    } else {
+      contentArray = this.transformPartsToToolCallContent(params.message);
+    }
+    if (isVisionBridgeNoticeDisplay(params.resultDisplay)) {
+      contentArray.unshift({
+        type: "content",
+        content: {
+          type: "text",
+          text: sanitizeTerminalText(
+            formatVisionBridgeNoticeDisplay(params.resultDisplay)
+          )
+        }
+      });
+    }
+    const provenance = _ToolCallEmitter.resolveToolProvenance(
+      params.toolName,
+      params.subagentMeta
+    );
+    const update = {
+      sessionUpdate: "tool_call_update",
+      toolCallId: params.callId,
+      status: params.success ? "completed" : "failed",
+      content: contentArray,
+      _meta: {
+        toolName: params.toolName,
+        ...params.subagentMeta,
+        provenance: provenance.provenance,
+        ...provenance.serverId ? { serverId: provenance.serverId } : {},
+        ...BaseEmitter.toEpochMs(params.timestamp) != null && {
+          timestamp: BaseEmitter.toEpochMs(params.timestamp)
+        },
+        ...params.artifacts && params.artifacts.length > 0 ? { artifacts: params.artifacts } : {}
+      }
+    };
+    if (params.resultDisplay !== void 0 && !this.isTruncatedSessionDiffDisplay(params.resultDisplay)) {
+      update["rawOutput"] = params.resultDisplay;
     }
+    await this.sendUpdate(update);
   }
   /**
-   * Emits a visible notice marking a break in the persisted history chain: an
-   * earlier segment was physically lost (storage interruption) and could not be
-   * recovered, so the surviving turns below must not be read as contiguous with
-   * whatever came before the gap. Uses the agent message channel — the same one
-   * used for other system notices (see MessageEmitter.emitStopHookLoop) — so no
-   * new session-update kind is needed.
+   * Emits a tool call error event.
+   * Use this for explicit error handling when not using emitResult.
+   *
+   * @param callId - The tool call ID
+   * @param toolName - The tool name
+   * @param error - The error that occurred
+   * @param subagentMeta - Optional subagent metadata
    */
-  async emitHistoryGapNotice(gap, timestamp) {
-    await this.messageEmitter.emitAgentMessage(
-      formatHistoryGapNotice(gap),
-      timestamp
+  async emitError(callId, toolName, error, subagentMeta) {
+    this.preparedCallIds.delete(callId);
+    const provenance = _ToolCallEmitter.resolveToolProvenance(
+      toolName,
+      subagentMeta
     );
+    await this.sendUpdate({
+      sessionUpdate: "tool_call_update",
+      toolCallId: callId,
+      status: "failed",
+      content: [
+        { type: "content", content: { type: "text", text: error.message } }
+      ],
+      _meta: {
+        toolName,
+        ...subagentMeta,
+        provenance: provenance.provenance,
+        ...provenance.serverId ? { serverId: provenance.serverId } : {}
+      }
+    });
   }
   /**
-   * Replays content from a message (user or assistant).
-   * Handles text parts, thought parts, and function calls.
+   * Resolve a tool's provenance for UI dispatch on tool_call events.
+   * The SDK reads `_meta.
+   * provenance` + `_meta.serverId` to render builtin / MCP-server-badge /
+   * subagent-block differently. Without this stamping, the SDK falls
+   * back to string-matching the toolName which can't reliably
+   * distinguish builtin from subagent.
    *
-   * @param content - The content to replay
-   * @param role - The role (user or assistant)
-   * @param timestamp - Optional server-side timestamp from the JSONL record
+   * Resolution rules:
+   *   - `subagentMeta` present → `'subagent'` (a Task tool / Codex
+   *     subagent / etc. wrapping its own tool calls)
+   *   - toolName matches `mcp__<server>__<tool>` → `'mcp'` with
+   *     `serverId: <server>`. Naming convention from
+   *     `packages/core/src/tools/mcp-tool.ts` in the
+   *     `@qwen-code/qwen-code-core` package — mirrors the SDK's same
+   *     heuristic fallback so SDK consumers stay consistent with
+   *     daemon classification.
+   *   - everything else → `'builtin'`
+   *
+   * Static + pure so it can be unit-tested without an emitter
+   * instance. Exported via `ToolCallEmitter.resolveToolProvenance`.
    */
-  async replayContent(content, role, timestamp, recordId) {
-    for (const part of content.parts ?? []) {
-      if ("text" in part && part.text) {
-        const isThought = part.thought ?? false;
-        await this.messageEmitter.emitMessage(
-          part.text,
-          role,
-          isThought,
-          timestamp
-        );
-      }
-      if ("functionCall" in part && part.functionCall) {
-        const functionName = part.functionCall.name ?? "";
-        const sourceCallId = part.functionCall.id;
-        const callId = sourceCallId ?? `${functionName}-${Date.now()}`;
-        const emitted = await this.toolCallEmitter.emitStart({
-          toolName: functionName,
-          callId,
-          args: part.functionCall.args,
-          status: "in_progress",
-          timestamp
-        });
-        if (emitted && role === "assistant" && recordId && sourceCallId) {
-          this.pendingReplayToolCalls.set(callId, {
-            callId,
-            toolName: functionName,
-            timestamp,
-            recordId
-          });
-        }
+  static resolveToolProvenance(toolName, subagentMeta) {
+    if (subagentMeta !== void 0) {
+      return { provenance: "subagent" };
+    }
+    if (toolName.startsWith("mcp__")) {
+      const parts = toolName.split("__");
+      if (parts.length >= 3 && parts[1] && parts[1].length > 0) {
+        return { provenance: "mcp", serverId: parts[1] };
       }
     }
+    return { provenance: "builtin" };
   }
+  // ==================== Public Utilities ====================
   /**
-   * Replays usage metadata.
-   * @param usageMetadata - The usage metadata to replay
+   * Checks if a tool name is the TodoWriteTool.
+   * Exposed for external use in components that need to check this.
    */
-  async replayUsageMetadata(usageMetadata) {
-    await this.messageEmitter.emitUsageMetadata(usageMetadata);
+  isTodoWriteTool(toolName) {
+    return toolName === ToolNames.TODO_WRITE;
   }
   /**
-   * Replays a tool result record.
+   * Checks if a tool name is the ExitPlanModeTool.
    */
-  async replayToolResult(record) {
-    if (!record.message?.parts) {
-      return;
-    }
-    const result = record.toolCallResult;
-    const callId = getToolResultCallId(record);
-    this.pendingReplayToolCalls.delete(callId);
-    const toolName = this.extractToolNameFromRecord(record);
-    await this.toolCallEmitter.emitResult({
-      toolName,
-      callId,
-      success: !result?.error,
-      message: record.message.parts,
-      resultDisplay: result?.resultDisplay,
-      artifacts: result?.artifacts,
-      // For TodoWriteTool fallback, try to extract args from the record
-      // Note: args aren't stored in tool_result records by default
-      args: void 0,
-      timestamp: record.timestamp
-    });
-    const { resultDisplay } = result ?? {};
-    if (!!resultDisplay && typeof resultDisplay === "object" && "type" in resultDisplay && resultDisplay.type === "task_execution") {
-      await this.emitTaskUsageFromResultDisplay(
-        resultDisplay
-      );
-    }
+  isExitPlanModeTool(toolName) {
+    return toolName === ToolNames.EXIT_PLAN_MODE;
   }
-  async failDanglingToolCalls() {
-    let firstError;
-    for (const pending of this.pendingReplayToolCalls.values()) {
-      this.setActiveRecordId(pending.recordId, pending.timestamp);
+  /**
+   * Checks if a tool name is the EnterPlanModeTool.
+   */
+  isEnterPlanModeTool(toolName) {
+    return toolName === ToolNames.ENTER_PLAN_MODE;
+  }
+  /**
+   * Resolves tool metadata from the registry.
+   * Falls back to defaults if tool not found or build fails.
+   *
+   * @param toolName - Name of the tool
+   * @param args - Tool call arguments (used to build invocation)
+   */
+  resolveToolMetadata(toolName, args) {
+    if (!hasFullSessionContext(this.ctx)) {
+      const description = typeof args?.["description"] === "string" ? args["description"].trim() : "";
+      return {
+        title: description ? `${toolName}: ${description}` : toolName,
+        locations: [],
+        kind: "other"
+      };
+    }
+    const toolRegistry = this.ctx.config.getToolRegistry();
+    const tool = toolRegistry.getTool(toolName);
+    let title = tool?.displayName ?? toolName;
+    let locations = [];
+    let kind = "other";
+    if (tool && args) {
       try {
-        await this.toolCallEmitter.emitResult({
-          toolName: pending.toolName,
-          callId: pending.callId,
-          success: false,
-          message: [],
-          error: new Error(MISSING_TOOL_RESULT_MESSAGE),
-          timestamp: pending.timestamp
-        });
-      } catch (error) {
-        firstError ??= error;
-      } finally {
-        this.setActiveRecordId(null);
+        const invocation = tool.build(args);
+        title = `${title}: ${invocation.getDescription()}`;
+        locations = invocation.toolLocations().map((loc) => ({
+          path: loc.path,
+          line: loc.line ?? null
+        }));
+        kind = this.mapToolKind(tool.kind, toolName);
+      } catch {
+        if (typeof args["description"] === "string") {
+          title = `${title}: ${args["description"]}`;
+        }
+        if (tool.kind) {
+          kind = this.mapToolKind(tool.kind, toolName);
+        }
       }
     }
-    if (firstError) {
-      throw firstError;
-    }
+    return { title, locations, kind };
   }
   /**
-   * Emits token usage from a AgentResultDisplay execution summary, if present.
+   * Maps core Tool Kind enum to ACP ToolKind string literals.
+   *
+   * @param kind - The core Kind enum value
+   * @param toolName - Optional tool name to handle special cases like exit_plan_mode
    */
-  async emitTaskUsageFromResultDisplay(resultDisplay) {
-    const summary = resultDisplay.executionSummary;
-    if (!summary) {
-      return;
-    }
-    const usageMetadata = {};
-    if (Number.isFinite(summary.inputTokens)) {
-      usageMetadata.promptTokenCount = summary.inputTokens;
-    }
-    if (Number.isFinite(summary.outputTokens)) {
-      usageMetadata.candidatesTokenCount = summary.outputTokens;
-    }
-    if (Number.isFinite(summary.thoughtTokens)) {
-      usageMetadata.thoughtsTokenCount = summary.thoughtTokens;
-    }
-    if (Number.isFinite(summary.cachedTokens)) {
-      usageMetadata.cachedContentTokenCount = summary.cachedTokens;
-    }
-    if (Number.isFinite(summary.totalTokens)) {
-      usageMetadata.totalTokenCount = summary.totalTokens;
-    }
-    if (Object.keys(usageMetadata).length > 0) {
-      await this.messageEmitter.emitUsageMetadata(usageMetadata);
+  mapToolKind(kind, toolName) {
+    if (toolName && (this.isExitPlanModeTool(toolName) || this.isEnterPlanModeTool(toolName))) {
+      return "switch_mode";
     }
+    return KIND_MAP[kind] ?? "other";
   }
+  // ==================== Private Helpers ====================
   /**
-   * Replays a slash_command system record by re-emitting its output as an
-   * agent message chunk. This allows Zed to reconstruct the correct turn
-   * structure (user → agent) on session resume without polluting model context.
+   * Extracts diff content from resultDisplay if it's a diff type (edit tool result).
+   * Returns null if not a diff.
    */
-  async replaySlashCommandResult(record) {
-    const payload = record.systemPayload;
-    if (payload?.phase !== "result" || !payload.outputHistoryItems?.length) {
-      return;
-    }
-    for (const item of payload.outputHistoryItems) {
-      const text = typeof item["text"] === "string" ? item["text"] : "";
-      if (text) {
-        await this.messageEmitter.emitAgentMessage(
-          text.replace(/\n/g, "  \n"),
-          record.timestamp
-        );
+  extractDiffContent(resultDisplay) {
+    if (!resultDisplay || typeof resultDisplay !== "object") return null;
+    const obj = resultDisplay;
+    if ("fileName" in obj && "newContent" in obj) {
+      if (this.isTruncatedSessionDiffDisplay(resultDisplay)) {
+        return {
+          type: "content",
+          content: {
+            type: "text",
+            text: buildTruncatedDiffPreviewText(obj)
+          }
+        };
       }
+      return {
+        type: "diff",
+        path: obj["fileName"],
+        oldText: obj["originalContent"] ?? "",
+        newText: obj["newContent"]
+      };
     }
+    return null;
+  }
+  isTruncatedSessionDiffDisplay(resultDisplay) {
+    if (!resultDisplay || typeof resultDisplay !== "object") return false;
+    const obj = resultDisplay;
+    return obj["truncatedForSession"] === true && "fileName" in obj && "newContent" in obj;
   }
   /**
-   * Extracts tool name from a chat record's function response.
+   * Transforms Part[] to ToolCallContent[].
+   * Extracts text from functionResponse parts and text parts.
    */
-  extractToolNameFromRecord(record) {
-    if (record.message?.parts) {
-      for (const part of record.message.parts) {
-        if ("functionResponse" in part && part.functionResponse?.name) {
-          return part.functionResponse.name;
+  transformPartsToToolCallContent(parts) {
+    const result = [];
+    for (const part of parts) {
+      if ("text" in part && part.text) {
+        result.push({
+          type: "content",
+          content: { type: "text", text: part.text }
+        });
+      }
+      if ("functionResponse" in part && part.functionResponse) {
+        try {
+          const resp = part.functionResponse.response;
+          const outputField = resp["output"];
+          const errorField = resp["error"];
+          const responseText = typeof outputField === "string" ? outputField : typeof errorField === "string" ? errorField : JSON.stringify(resp);
+          result.push({
+            type: "content",
+            content: { type: "text", text: responseText }
+          });
+        } catch {
         }
       }
     }
-    return "";
-  }
-  setActiveRecordId(recordId, timestamp) {
-    const context = this.ctx;
-    if (typeof context.setActiveRecordId === "function") {
-      context.setActiveRecordId(recordId, timestamp);
-    }
+    return result;
   }
 };
 
-// packages/cli/src/services/setup-github.ts
+// packages/cli/src/acp-integration/session/history-replayer.ts
 init_esbuild_shims();
-var import_undici2 = __toESM(require_undici(), 1);
-import { promises as fsp } from "node:fs";
-import * as path from "node:path";
 
-// packages/cli/src/utils/gitUtils.ts
+// packages/cli/src/utils/chat-record-tool-call-id.ts
 init_esbuild_shims();
-var import_undici = __toESM(require_undici(), 1);
-import * as childProcess from "node:child_process";
-var debugLogger = createDebugLogger("GIT");
-async function runGit(args, opts = {}) {
-  return await new Promise((resolve2, reject) => {
-    childProcess.execFile(
-      "git",
-      args,
-      {
-        encoding: "utf-8",
-        ...opts.cwd ? { cwd: opts.cwd } : {}
-      },
-      (err, stdout) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve2(String(stdout ?? "").trim());
-      }
-    );
-  });
+function getToolResultCallId(record) {
+  return getExplicitToolResultCallId(record) ?? record.uuid;
 }
-__name(runGit, "runGit");
-var isGitHubRepositoryAsync = /* @__PURE__ */ __name(async (opts = {}) => {
-  try {
-    const remotes = await runGit(["remote", "-v"], opts);
-    return remotes.split("\n").some((line) => {
-      const remoteUrl = line.trim().split(/\s+/)[1];
-      return remoteUrl ? isGitHubRemoteUrl(remoteUrl) : false;
-    });
-  } catch (_error) {
-    debugLogger.debug(`Failed to get git remote:`, _error);
-    return false;
-  }
-}, "isGitHubRepositoryAsync");
-function isGitHubRemoteUrl(remoteUrl) {
-  if (remoteUrl.startsWith("git@github.com:")) {
-    return true;
-  }
-  if (remoteUrl.startsWith("git@")) {
-    return false;
-  }
-  try {
-    return new URL(remoteUrl).hostname === "github.com";
-  } catch {
-    return false;
+__name(getToolResultCallId, "getToolResultCallId");
+function getExplicitToolResultCallId(record) {
+  const resultCallId = record.toolCallResult?.callId;
+  if (typeof resultCallId === "string" && resultCallId.length > 0) {
+    return resultCallId;
   }
+  return extractFunctionResponseId(record);
 }
-__name(isGitHubRemoteUrl, "isGitHubRemoteUrl");
-var getGitRepoRootAsync = /* @__PURE__ */ __name(async (opts = {}) => {
-  const gitRepoRoot = await runGit(["rev-parse", "--show-toplevel"], opts);
-  if (!gitRepoRoot) {
-    throw new Error(`Git repo returned empty value`);
+__name(getExplicitToolResultCallId, "getExplicitToolResultCallId");
+function extractFunctionResponseId(record) {
+  if (!record.message?.parts) {
+    return void 0;
   }
-  return gitRepoRoot;
-}, "getGitRepoRootAsync");
-var getLatestGitHubRelease = /* @__PURE__ */ __name(async (proxy) => {
-  try {
-    const controller = new AbortController();
-    const endpoint = `https://api.github.com/repos/QwenLM/qwen-code-action/releases/latest`;
-    const response = await fetch(endpoint, {
-      method: "GET",
-      headers: {
-        Accept: "application/vnd.github+json",
-        "Content-Type": "application/json",
-        "X-GitHub-Api-Version": "2022-11-28"
-      },
-      dispatcher: proxy ? new import_undici.ProxyAgent(proxy) : void 0,
-      signal: AbortSignal.any([AbortSignal.timeout(3e4), controller.signal])
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Invalid response code: ${response.status} - ${response.statusText}`
-      );
-    }
-    const releaseTag = (await response.json()).tag_name;
-    if (!releaseTag) {
-      throw new Error(`Response did not include tag_name field`);
+  for (const part of record.message.parts) {
+    const id = "functionResponse" in part ? part.functionResponse?.id : void 0;
+    if (typeof id === "string" && id.length > 0) {
+      return id;
     }
-    return releaseTag;
-  } catch (_error) {
-    debugLogger.debug(
-      `Failed to determine latest qwen-code-action release:`,
-      _error
-    );
-    throw new Error(
-      `Unable to determine the latest qwen-code-action release on GitHub.`
-    );
-  }
-}, "getLatestGitHubRelease");
-async function getGitHubRepoInfoAsync(opts = {}) {
-  return parseGitHubRepoInfo(
-    await runGit(["remote", "get-url", "origin"], opts)
-  );
-}
-__name(getGitHubRepoInfoAsync, "getGitHubRepoInfoAsync");
-function parseGitHubRepoInfo(remoteUrl) {
-  let urlToParse = remoteUrl;
-  if (remoteUrl.startsWith("git@github.com:")) {
-    urlToParse = remoteUrl.replace("git@github.com:", "");
-  } else if (remoteUrl.startsWith("git@")) {
-    throw new Error(
-      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`
-    );
   }
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(urlToParse, "https://github.com");
-  } catch {
-    throw new Error(
-      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`
-    );
-  }
-  if (parsedUrl.hostname !== "github.com") {
-    throw new Error(
-      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`
-    );
-  }
-  const parts = parsedUrl.pathname.split("/").filter((part) => part !== "");
-  if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new Error(
-      `Owner & repo could not be extracted from remote URL: ${remoteUrl}`
-    );
-  }
-  return { owner: parts[0], repo: parts[1].replace(/\.git$/, "") };
+  return void 0;
 }
-__name(parseGitHubRepoInfo, "parseGitHubRepoInfo");
+__name(extractFunctionResponseId, "extractFunctionResponseId");
 
-// packages/cli/src/services/setup-github.ts
-var debugLogger2 = createDebugLogger("SETUP_GITHUB");
-var GITHUB_WORKFLOW_PATHS = [
-  "qwen-dispatch/qwen-dispatch.yml",
-  "qwen-assistant/qwen-invoke.yml",
-  "issue-triage/qwen-triage.yml",
-  "issue-triage/qwen-scheduled-triage.yml",
-  "pr-review/qwen-review.yml"
-];
-var GITIGNORE_ENTRIES = [".qwen/", "gha-creds-*.json"];
-var MAX_WORKFLOW_DOWNLOAD_BYTES = 5 * 1024 * 1024;
-var SetupGithubError = class extends Error {
+// packages/cli/src/acp-integration/session/history-replayer.ts
+var MISSING_TOOL_RESULT_MESSAGE = "Tool result missing from saved history; the previous run likely ended before this tool completed.";
+var HistoryReplayer = class {
   static {
-    __name(this, "SetupGithubError");
+    __name(this, "HistoryReplayer");
   }
-  code;
-  status;
-  partial;
-  partialResult;
-  constructor(code, message, status, partialResult) {
-    super(message);
-    this.name = "SetupGithubError";
-    this.code = code;
-    this.status = status;
-    this.partial = partialResult !== void 0;
-    this.partialResult = partialResult;
+  ctx;
+  messageEmitter;
+  toolCallEmitter;
+  pendingReplayToolCalls = /* @__PURE__ */ new Map();
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.messageEmitter = new MessageEmitter(ctx);
+    this.toolCallEmitter = new ToolCallEmitter(ctx);
   }
-};
-var nodeFileOps = {
-  assertCanWrite() {
-  },
-  async ensureWorkflowDirectory(gitRepoRoot) {
-    await fsp.mkdir(path.join(gitRepoRoot, ".github", "workflows"), {
-      recursive: true
-    });
-  },
-  async writeTextFile(gitRepoRoot, relativePath, content) {
-    const target = path.join(gitRepoRoot, relativePath);
-    await fsp.writeFile(target, content, { mode: 420 });
-    return { sizeBytes: Buffer.byteLength(content, "utf8") };
-  },
-  async readTextFile(gitRepoRoot, relativePath) {
+  /**
+   * Replays all chat records from a loaded session.
+   *
+   * @param records - Array of chat records to replay
+   * @param gaps - Optional detected history gaps; a visible notice is emitted
+   *   immediately before each gap's child record so the user sees that an
+   *   earlier segment was lost rather than assuming the halves are contiguous.
+   */
+  async replay(records, gaps) {
+    try {
+      await this.replayPage(records, { finalizeDangling: true, gaps });
+    } finally {
+      this.pendingReplayToolCalls.clear();
+      this.setActiveRecordId(null);
+    }
+  }
+  async replayPage(records, options = {}) {
+    this.pendingReplayToolCalls.clear();
+    for (const pending of options.pendingToolCalls ?? []) {
+      this.pendingReplayToolCalls.set(pending.callId, pending);
+    }
+    const gapByChildUuid = indexGapsByChild(options.gaps);
+    let replayError;
     try {
-      return await fsp.readFile(path.join(gitRepoRoot, relativePath), "utf8");
+      for (const record of records) {
+        const gap = gapByChildUuid.get(record.uuid);
+        if (gap) {
+          await this.emitHistoryGapNotice(gap, record.timestamp);
+        }
+        await this.replayRecord(record);
+      }
     } catch (error) {
-      if (error.code === "ENOENT") {
-        return void 0;
+      replayError = error;
+    }
+    let danglingError;
+    if (options.finalizeDangling === true) {
+      try {
+        await this.failDanglingToolCalls();
+      } catch (error) {
+        danglingError = error;
       }
-      throw error;
     }
+    const state = {
+      pendingToolCalls: options.finalizeDangling === true ? [] : Array.from(this.pendingReplayToolCalls.values())
+    };
+    this.setActiveRecordId(null);
+    if (replayError && danglingError) {
+      throw new AggregateError(
+        [replayError, danglingError],
+        "Replay and dangling-cleanup both failed"
+      );
+    }
+    if (replayError) {
+      throw replayError;
+    }
+    if (danglingError) {
+      throw danglingError;
+    }
+    return state;
   }
-};
-async function setupGithub(options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const fileOps = options.fileOps ?? nodeFileOps;
-  if (!await isGitHubRepositoryAsync({ cwd })) {
-    throw new SetupGithubError(
-      "github_repository_not_found",
-      "Unable to determine the GitHub repository. /setup-github must be run from a git repository.",
-      400
-    );
-  }
-  let gitRepoRoot;
-  try {
-    gitRepoRoot = await getGitRepoRootAsync({ cwd });
-  } catch (error) {
-    debugLogger2.debug("Failed to get git repo root:", error);
-    throw new SetupGithubError(
-      "github_repository_not_found",
-      "Unable to determine the GitHub repository. /setup-github must be run from a git repository.",
-      400
-    );
+  getPendingToolCalls() {
+    return Array.from(this.pendingReplayToolCalls.values());
   }
-  if (options.workspaceRoot) {
-    const [gitRootReal, workspaceReal] = await Promise.all([
-      realpathOrResolve(gitRepoRoot),
-      realpathOrResolve(options.workspaceRoot)
-    ]);
-    if (gitRootReal !== workspaceReal) {
-      throw new SetupGithubError(
-        "github_git_root_mismatch",
-        "The Git repository root must match the daemon workspace root.",
-        400
-      );
+  /**
+   * Replays a single chat record.
+   */
+  async replayRecord(record) {
+    this.setActiveRecordId(record.uuid, record.timestamp);
+    try {
+      switch (record.type) {
+        case "user":
+          if (record.subtype === "notification" || record.subtype === "cron") {
+            const displayText = record.systemPayload?.displayText;
+            if (displayText) {
+              await this.messageEmitter.emitUserMessage(
+                displayText,
+                record.timestamp,
+                record.subtype === "cron" ? { source: "cron" } : void 0
+              );
+            }
+            break;
+          }
+          if (record.subtype === "mid_turn_user_message") {
+            const displayText = record.systemPayload?.displayText;
+            if (displayText) {
+              await this.messageEmitter.emitUserMessage(
+                displayText,
+                record.timestamp
+              );
+            } else if (record.message) {
+              await this.replayContent(
+                record.message,
+                "user",
+                record.timestamp,
+                record.uuid
+              );
+            }
+            break;
+          }
+          if (record.message) {
+            await this.replayContent(
+              record.message,
+              "user",
+              record.timestamp,
+              record.uuid
+            );
+          }
+          break;
+        case "assistant":
+          if (record.message) {
+            await this.replayContent(
+              record.message,
+              "assistant",
+              record.timestamp,
+              record.uuid
+            );
+          }
+          if (record.usageMetadata) {
+            await this.replayUsageMetadata(record.usageMetadata);
+          }
+          break;
+        case "tool_result":
+          await this.replayToolResult(record);
+          break;
+        case "system":
+          if (record.subtype === "slash_command") {
+            await this.replaySlashCommandResult(record);
+          }
+          break;
+        default:
+          break;
+      }
+    } finally {
+      this.setActiveRecordId(null);
     }
   }
-  fileOps.assertCanWrite?.();
-  let releaseTag;
-  try {
-    releaseTag = await getLatestGitHubRelease(options.proxy);
-  } catch (error) {
-    writeStderrLine(
-      `qwen setup-github: failed to determine latest qwen-code-action release: ${error instanceof Error ? error.message : String(error)}`
-    );
-    debugLogger2.debug(
-      "Failed to determine latest qwen-code-action release:",
-      error
-    );
-    throw new SetupGithubError(
-      "github_release_lookup_failed",
-      "Unable to determine the latest qwen-code-action release on GitHub.",
-      502
+  /**
+   * Emits a visible notice marking a break in the persisted history chain: an
+   * earlier segment was physically lost (storage interruption) and could not be
+   * recovered, so the surviving turns below must not be read as contiguous with
+   * whatever came before the gap. Uses the agent message channel — the same one
+   * used for other system notices (see MessageEmitter.emitStopHookLoop) — so no
+   * new session-update kind is needed.
+   */
+  async emitHistoryGapNotice(gap, timestamp) {
+    await this.messageEmitter.emitAgentMessage(
+      formatHistoryGapNotice(gap),
+      timestamp
     );
   }
-  const readmeUrl = `https://github.com/QwenLM/qwen-code-action/blob/${releaseTag}/README.md#quick-start`;
-  const secretsUrl = await resolveSecretsUrl(cwd);
-  const downloads = await downloadWorkflows({
-    releaseTag,
-    proxy: options.proxy,
-    abortSignal: options.abortSignal,
-    fetchImpl: options.fetchImpl ?? fetch
-  });
-  const result = {
-    kind: "github_setup",
-    workspaceCwd: options.workspaceRoot ?? gitRepoRoot,
-    gitRepoRoot,
-    releaseTag,
-    readmeUrl,
-    ...secretsUrl ? { secretsUrl } : {},
-    workflows: [],
-    gitignore: { path: ".gitignore", status: "skipped" },
-    warnings: []
-  };
-  result.gitignore = await updateGitignore(gitRepoRoot, fileOps);
-  if (result.gitignore.status === "failed") {
-    result.warnings.push("Failed to update .gitignore.");
+  /**
+   * Replays content from a message (user or assistant).
+   * Handles text parts, thought parts, and function calls.
+   *
+   * @param content - The content to replay
+   * @param role - The role (user or assistant)
+   * @param timestamp - Optional server-side timestamp from the JSONL record
+   */
+  async replayContent(content, role, timestamp, recordId) {
+    for (const part of content.parts ?? []) {
+      if ("text" in part && part.text) {
+        const isThought = part.thought ?? false;
+        await this.messageEmitter.emitMessage(
+          part.text,
+          role,
+          isThought,
+          timestamp
+        );
+      }
+      if ("functionCall" in part && part.functionCall) {
+        const functionName = part.functionCall.name ?? "";
+        const sourceCallId = part.functionCall.id;
+        const callId = sourceCallId ?? `${functionName}-${Date.now()}`;
+        const emitted = await this.toolCallEmitter.emitStart({
+          toolName: functionName,
+          callId,
+          args: part.functionCall.args,
+          status: "in_progress",
+          timestamp
+        });
+        if (emitted && role === "assistant" && recordId && sourceCallId) {
+          this.pendingReplayToolCalls.set(callId, {
+            callId,
+            toolName: functionName,
+            timestamp,
+            recordId
+          });
+        }
+      }
+    }
   }
-  try {
-    await fileOps.ensureWorkflowDirectory(gitRepoRoot);
-    for (const workflow of downloads) {
-      const relativePath = path.posix.join(
-        ".github",
-        "workflows",
-        path.posix.basename(workflow.sourcePath)
+  /**
+   * Replays usage metadata.
+   * @param usageMetadata - The usage metadata to replay
+   */
+  async replayUsageMetadata(usageMetadata) {
+    await this.messageEmitter.emitUsageMetadata(usageMetadata);
+  }
+  /**
+   * Replays a tool result record.
+   */
+  async replayToolResult(record) {
+    if (!record.message?.parts) {
+      return;
+    }
+    const result = record.toolCallResult;
+    const callId = getToolResultCallId(record);
+    this.pendingReplayToolCalls.delete(callId);
+    const toolName = this.extractToolNameFromRecord(record);
+    await this.toolCallEmitter.emitResult({
+      toolName,
+      callId,
+      success: !result?.error,
+      message: record.message.parts,
+      resultDisplay: result?.resultDisplay,
+      artifacts: result?.artifacts,
+      // For TodoWriteTool fallback, try to extract args from the record
+      // Note: args aren't stored in tool_result records by default
+      args: void 0,
+      timestamp: record.timestamp
+    });
+    const { resultDisplay } = result ?? {};
+    if (!!resultDisplay && typeof resultDisplay === "object" && "type" in resultDisplay && resultDisplay.type === "task_execution") {
+      await this.emitTaskUsageFromResultDisplay(
+        resultDisplay
       );
+    }
+  }
+  async failDanglingToolCalls() {
+    let firstError;
+    for (const pending of this.pendingReplayToolCalls.values()) {
+      this.setActiveRecordId(pending.recordId, pending.timestamp);
       try {
-        const write = await fileOps.writeTextFile(
-          gitRepoRoot,
-          relativePath,
-          workflow.content
-        );
-        result.workflows.push({
-          sourcePath: workflow.sourcePath,
-          path: relativePath,
-          status: "written",
-          sizeBytes: write.sizeBytes
+        await this.toolCallEmitter.emitResult({
+          toolName: pending.toolName,
+          callId: pending.callId,
+          success: false,
+          message: [],
+          error: new Error(MISSING_TOOL_RESULT_MESSAGE),
+          timestamp: pending.timestamp
         });
       } catch (error) {
-        result.partial = true;
-        result.workflows.push({
-          sourcePath: workflow.sourcePath,
-          path: relativePath,
-          status: "failed",
-          error: error instanceof Error ? error.message : String(error)
-        });
-        throw new SetupGithubError(
-          "github_workflow_write_failed",
-          `Unable to write ${relativePath}.`,
-          500,
-          result
-        );
+        firstError ??= error;
+      } finally {
+        this.setActiveRecordId(null);
       }
     }
-  } catch (error) {
-    if (error instanceof SetupGithubError) throw error;
-    throw new SetupGithubError(
-      "github_workflow_write_failed",
-      "Unable to create .github/workflows.",
-      500,
-      result
-    );
+    if (firstError) {
+      throw firstError;
+    }
   }
-  return result;
-}
-__name(setupGithub, "setupGithub");
-async function updateGitignore(gitRepoRoot, fileOps = nodeFileOps) {
-  try {
-    const existingContent = await fileOps.readTextFile(
-      gitRepoRoot,
-      ".gitignore"
-    );
-    if (existingContent === void 0) {
-      const content = GITIGNORE_ENTRIES.join("\n") + "\n";
-      await fileOps.writeTextFile(gitRepoRoot, ".gitignore", content);
-      return {
-        path: ".gitignore",
-        status: "created",
-        added: [...GITIGNORE_ENTRIES]
-      };
+  /**
+   * Emits token usage from a AgentResultDisplay execution summary, if present.
+   */
+  async emitTaskUsageFromResultDisplay(resultDisplay) {
+    const summary = resultDisplay.executionSummary;
+    if (!summary) {
+      return;
     }
-    const missingEntries = GITIGNORE_ENTRIES.filter(
-      (entry) => !existingContent.split(/\r?\n/).some((line) => line.split("#")[0].trim() === entry)
-    );
-    if (missingEntries.length === 0) {
-      return { path: ".gitignore", status: "unchanged" };
+    const usageMetadata = {};
+    if (Number.isFinite(summary.inputTokens)) {
+      usageMetadata.promptTokenCount = summary.inputTokens;
     }
-    const nextContent = existingContent + "\n" + missingEntries.join("\n") + "\n";
-    await fileOps.writeTextFile(gitRepoRoot, ".gitignore", nextContent);
-    return {
-      path: ".gitignore",
-      status: "updated",
-      added: missingEntries
-    };
-  } catch (error) {
-    debugLogger2.debug("Failed to update .gitignore:", error);
-    return {
-      path: ".gitignore",
-      status: "failed",
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-__name(updateGitignore, "updateGitignore");
-async function downloadWorkflows(options) {
-  const internalAbort = new AbortController();
-  try {
-    const dispatcher = options.proxy ? new import_undici2.ProxyAgent(options.proxy) : void 0;
-    return await Promise.all(
-      GITHUB_WORKFLOW_PATHS.map(async (workflow) => {
-        const endpoint = `https://raw.githubusercontent.com/QwenLM/qwen-code-action/refs/tags/${options.releaseTag}/examples/workflows/${workflow}`;
-        const response = await options.fetchImpl(endpoint, {
-          method: "GET",
-          dispatcher,
-          signal: AbortSignal.any([
-            AbortSignal.timeout(3e4),
-            internalAbort.signal,
-            ...options.abortSignal ? [options.abortSignal] : []
-          ])
-        });
-        if (!response.ok) {
-          throw new Error(
-            `Invalid response code downloading ${endpoint}: ${response.status} - ${response.statusText}`
-          );
-        }
-        return {
-          sourcePath: workflow,
-          content: await readResponseTextWithLimit(response, workflow)
-        };
-      })
-    );
-  } catch (error) {
-    internalAbort.abort();
-    const message = error instanceof Error ? error.message : String(error);
-    debugLogger2.debug("Failed to download qwen-code-action workflows:", error);
-    throw new SetupGithubError(
-      "github_workflow_download_failed",
-      `Unable to download qwen-code-action workflows from GitHub. ${message}`,
-      502
-    );
-  }
-}
-__name(downloadWorkflows, "downloadWorkflows");
-async function readResponseTextWithLimit(response, sourcePath) {
-  const contentLength = response.headers.get("content-length");
-  if (contentLength !== null) {
-    const parsedLength = Number(contentLength);
-    if (Number.isFinite(parsedLength) && parsedLength > MAX_WORKFLOW_DOWNLOAD_BYTES) {
-      throw new Error(
-        `${sourcePath} exceeds download limit of ${MAX_WORKFLOW_DOWNLOAD_BYTES} bytes`
-      );
+    if (Number.isFinite(summary.outputTokens)) {
+      usageMetadata.candidatesTokenCount = summary.outputTokens;
+    }
+    if (Number.isFinite(summary.thoughtTokens)) {
+      usageMetadata.thoughtsTokenCount = summary.thoughtTokens;
+    }
+    if (Number.isFinite(summary.cachedTokens)) {
+      usageMetadata.cachedContentTokenCount = summary.cachedTokens;
+    }
+    if (Number.isFinite(summary.totalTokens)) {
+      usageMetadata.totalTokenCount = summary.totalTokens;
+    }
+    if (Object.keys(usageMetadata).length > 0) {
+      await this.messageEmitter.emitUsageMetadata(usageMetadata);
     }
   }
-  if (!response.body) return "";
-  const reader = response.body.getReader();
-  const chunks = [];
-  let totalBytes = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (!value) continue;
-      totalBytes += value.byteLength;
-      if (totalBytes > MAX_WORKFLOW_DOWNLOAD_BYTES) {
-        await reader.cancel().catch(() => {
-        });
-        throw new Error(
-          `${sourcePath} exceeds download limit of ${MAX_WORKFLOW_DOWNLOAD_BYTES} bytes`
+  /**
+   * Replays a slash_command system record by re-emitting its output as an
+   * agent message chunk. This allows Zed to reconstruct the correct turn
+   * structure (user → agent) on session resume without polluting model context.
+   */
+  async replaySlashCommandResult(record) {
+    const payload = record.systemPayload;
+    if (payload?.phase !== "result" || !payload.outputHistoryItems?.length) {
+      return;
+    }
+    for (const item of payload.outputHistoryItems) {
+      const text = typeof item["text"] === "string" ? item["text"] : "";
+      if (text) {
+        await this.messageEmitter.emitSlashCommandOutput(
+          text.replace(/\n/g, "  \n"),
+          record.timestamp
         );
       }
-      chunks.push(value);
     }
-  } finally {
-    reader.releaseLock();
-  }
-  const body = new Uint8Array(totalBytes);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
   }
-  return new TextDecoder().decode(body);
-}
-__name(readResponseTextWithLimit, "readResponseTextWithLimit");
-async function resolveSecretsUrl(cwd) {
-  try {
-    const repoInfo = await getGitHubRepoInfoAsync({ cwd });
-    return `https://github.com/${repoInfo.owner}/${repoInfo.repo}/settings/secrets/actions`;
-  } catch {
-    return void 0;
+  /**
+   * Extracts tool name from a chat record's function response.
+   */
+  extractToolNameFromRecord(record) {
+    if (record.message?.parts) {
+      for (const part of record.message.parts) {
+        if ("functionResponse" in part && part.functionResponse?.name) {
+          return part.functionResponse.name;
+        }
+      }
+    }
+    return "";
   }
-}
-__name(resolveSecretsUrl, "resolveSecretsUrl");
-async function realpathOrResolve(input) {
-  try {
-    return await fsp.realpath(input);
-  } catch {
-    return path.resolve(input);
+  setActiveRecordId(recordId, timestamp) {
+    const context = this.ctx;
+    if (typeof context.setActiveRecordId === "function") {
+      context.setActiveRecordId(recordId, timestamp);
+    }
   }
-}
-__name(realpathOrResolve, "realpathOrResolve");
+};
 
 // packages/cli/src/ui/utils/export/collect.ts
 init_esbuild_shims();
@@ -1646,7 +1735,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./src-G5UPLZSZ.js");
+    const { getGitRepoName } = await import("./src-7FITDSVC.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;
@@ -1961,7 +2050,19 @@ function buildToolCallMessageFromResult(record, config) {
   const rawInput = normalizeRawInput(
     functionCallArgs ?? toolCallResult?.args
   );
-  const content = extractDiffContent(toolCallResult?.resultDisplay) ?? transformPartsToToolCallContent(record.message?.parts ?? []);
+  const resultContent = extractDiffContent(toolCallResult?.resultDisplay) ?? transformPartsToToolCallContent(record.message?.parts ?? []);
+  const content = isVisionBridgeNoticeDisplay(toolCallResult?.resultDisplay) ? [
+    {
+      type: "content",
+      content: {
+        type: "text",
+        text: sanitizeTerminalText(
+          formatVisionBridgeNoticeDisplay(toolCallResult.resultDisplay)
+        )
+      }
+    },
+    ...resultContent
+  ] : resultContent;
   return {
     uuid: record.uuid,
     parentUuid: record.parentUuid,
@@ -2491,7 +2592,7 @@ export {
 };
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
@@ -2501,7 +2602,7 @@ export {
  */
 /**
  * @license
- * Copyright 2025 Google LLC
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**