wtagent 0.1.0-alpha.1 → 0.1.0-alpha.2

package/docs/technical-design.md

@@ -593,7 +593,7 @@ sessions/<session-id>/
   tool-output.jsonl
 ```
 
-`session.json` 保存项目根目录、ChatGPT 会话 URL、当前 run phase、最近 turn、等待回填的工具结果和副作用恢复日志。它没有不可继续的 `completed task` 状态；`done=true` 只结束当前 run，Session 回到 `idle`。
+`session.json` 保存项目根目录、ChatGPT 会话 URL、最近确认的 assistant message ID、最近确认的实际模式、当前 run phase、最近 turn、等待回填的工具结果和副作用恢复日志。它没有不可继续的 `completed task` 状态；`done=true` 只结束当前 run，Session 回到 `idle`。
 
 `rollout-*.jsonl` 从创建时起直接使用 **Codex rollout 风格**：首行 `session_meta`，后续每行 `{timestamp, type: "response_item", payload}`，payload 采用 OpenAI Responses 形状（`message` / `function_call` / `function_call_output`）。
 
@@ -628,6 +628,8 @@ sessionId + assistantMessageIdentity + normalizedToolCall
 
 - Chrome 仍在：根据专用 Profile、PID、CDP 端口和健康检查验证身份，复用浏览器并创建新的 Page。
 - Chrome 崩溃：用相同 Profile 重启并打开会话 URL。
+- 同一 CLI 进程中的 follow-up 保持在当前会话 Page，不重复导航；跨进程恢复需要等待本地记录的最近 assistant message ID 出现在 DOM 后才能发送。
+- 每次发送记录已有消息 ID 和新 user turn，只接受位于该 user turn 之后的新 assistant turn；无法建立可靠消息身份时超时并保存诊断，禁止退化为基于数量或文本变化猜测。
 - 同一 Profile 同时只允许一个 WTAgent CLI Session；启动和接管过程使用 Profile 级互斥锁。
 - 登录失效或出现验证：进入 `AUTH_REQUIRED`/`PAUSED`，让用户接管。
 - 会话页面丢失：从本地记录打开原会话；无法恢复时创建新的本地 Session 和新的网页对话，不向旧 rollout 继续追加。
@@ -640,6 +642,8 @@ sessionId + assistantMessageIdentity + normalizedToolCall
 2. 当前可用工具及参数 Schema。
 3. 用户任务、项目根目录语义和执行边界。
 
+同一网页会话中的普通 follow-up 只发送新的用户输入，并在末尾追加短 `<system_reminder>`；不得重复发送完整 `<agent_protocol>`、工具目录或初始任务。只有没有新用户输入的中断恢复流程可以发送完整 resume scaffold。
+
 关键规则：
 
 - 一轮最多一个工具调用。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtagent",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.2",
   "description": "Turn your own web AI session into a local tool-using agent.",
   "repository": {
     "type": "git",

package/src/browser/cdp-browser.js

@@ -7,6 +7,7 @@ import {
   discoverReusableCdpState,
   fetchCdpVersion,
   processMatchesCdpState,
+  reapStaleProfileChrome,
   removeCdpState,
   saveCdpState,
   waitForProcessExit,
@@ -45,6 +46,33 @@ async function settleWithin(promise, timeoutMs) {
   }
 }
 
+// Races a promise against a timeout. On timeout the returned promise rejects
+// with a TIMEOUT-tagged error. Used to bound connectOverCDP + the first CDP
+// round-trip: a Chrome whose profile is locked by a stale instance answers the
+// WS handshake but never finishes protocol init, so an unbounded connect hangs
+// for the full Playwright default (30s) before failing.
+class CdpTimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CdpTimeoutError";
+    this.code = "CDP_CONNECT_TIMEOUT";
+  }
+}
+
+async function withTimeout(promise, timeoutMs, message) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new CdpTimeoutError(message)), timeoutMs);
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 async function waitForCdp({
   endpoint,
   child,
@@ -116,12 +144,14 @@ export async function launchAndConnectCdpChrome({
   fetchVersion = fetchCdpVersion,
   killTree = killProcessTree,
   matchesState = processMatchesCdpState,
+  reapStale = reapStaleProfileChrome,
   removeState = removeCdpState,
   reserveCdpPort = reservePort,
   saveState = saveCdpState,
   spawnChrome = spawn,
   waitForExit = waitForProcessExit,
   waitForReady = waitForCdp,
+  connectTimeoutMs = 20_000,
 } = {}) {
   const releaseProfileLock = await acquireProfileLock(profileDir);
   let child = null;
@@ -140,6 +170,11 @@ export async function launchAndConnectCdpChrome({
       reused = true;
     } else {
       await removeState(profileDir);
+      // A prior instance may have died leaving renderer children (and Chrome's
+      // SingletonLock) still holding this profile. Reap those stale holders
+      // before launching, or the new Chrome hangs during profile init and
+      // connectOverCDP times out.
+      await reapStale(profileDir, { fetchVersion, killTree }).catch(() => null);
       const port = await reserveCdpPort();
       const endpoint = `http://127.0.0.1:${port}`;
       child = spawnChrome(
@@ -192,8 +227,41 @@ export async function launchAndConnectCdpChrome({
       }
     }
 
-    browser = await connectOverCDP(state.endpoint);
-    const context = browser.contexts()[0];
+    // Bound the connect + first CDP round-trip. If Chrome's profile is held by
+    // a stale instance, the WS connects but protocol init never completes;
+    // without this guard Playwright hangs ~30s and leaves a dirty CDP state.
+    let context;
+    try {
+      browser = await withTimeout(
+        connectOverCDP(state.endpoint),
+        connectTimeoutMs,
+        `Timed out connecting to Chrome CDP at ${state.endpoint} after ${connectTimeoutMs}ms.`,
+      );
+      // contexts() forces a real protocol round-trip, so it hangs too when the
+      // browser main thread is stuck — keep it inside the timeout budget.
+      const contexts = await withTimeout(
+        Promise.resolve().then(() => browser.contexts()),
+        connectTimeoutMs,
+        `Timed out reading Chrome browser context at ${state.endpoint}.`,
+      );
+      context = contexts[0];
+    } catch (error) {
+      if (error instanceof CdpTimeoutError) {
+        // The verified-but-unusable instance we launched is a dead end. Kill it
+        // (only if we own it) and drop its CDP state so the next run starts
+        // clean instead of trying to reuse a hung endpoint.
+        await browser?.close().catch(() => null);
+        if (!reused && child?.pid) {
+          await killTree(child.pid).catch(() => null);
+        }
+        await removeState(profileDir, state).catch(() => null);
+        throw new Error(
+          `${error.message} The Chrome profile may be held by another instance. `
+          + "Close other windows using this profile, or run `wtagent logout` to reset it, then retry.",
+        );
+      }
+      throw error;
+    }
     if (!context) {
       throw new Error("Chrome CDP connection did not expose a browser context.");
     }

package/src/browser/cdp-state.js

@@ -335,6 +335,66 @@ export async function discoverReusableCdpState(profileDir, {
   );
 }
 
+// Kills Chrome processes bound to this profile whose CDP endpoint is dead, and
+// clears Chrome's singleton guard files. A half-dead prior instance (main
+// process gone or unresponsive, but renderer children still holding the
+// profile) makes a freshly launched Chrome hang during profile initialization:
+// the new CDP port answers HTTP/WS, but the browser main thread never becomes
+// usable, so connectOverCDP times out. Reaping those stale holders first
+// prevents the hang. Only ever touches processes that use THIS profile dir, and
+// never a live/healthy CDP instance. Best-effort.
+export async function reapStaleProfileChrome(profileDir, {
+  isAlive = isProcessAlive,
+  fetchVersion = fetchCdpVersion,
+  listProcesses = readProcessTable,
+  killTree = null,
+} = {}) {
+  const resolvedProfile = path.resolve(profileDir);
+  let processes;
+  try {
+    processes = await listProcesses();
+  } catch {
+    return { killed: [] };
+  }
+
+  const candidates = processes
+    .map((entry) => candidateFromProcess(entry, resolvedProfile))
+    .filter(Boolean);
+
+  const killed = [];
+  for (const candidate of candidates) {
+    // "Stale" = the CDP endpoint does not answer a healthy version probe. A
+    // healthy instance is left alone (it is a reuse candidate elsewhere).
+    let healthy = false;
+    try {
+      await fetchVersion(`http://127.0.0.1:${candidate.port}`);
+      healthy = true;
+    } catch {
+      healthy = false;
+    }
+    if (healthy) {
+      continue;
+    }
+    if (isAlive(candidate.pid) && typeof killTree === "function") {
+      await killTree(candidate.pid).catch(() => {});
+    }
+    killed.push(candidate.pid);
+  }
+
+  // Chrome's singleton profile guard is a symlink; a crashed instance can leave
+  // it dangling and block the next launch. Clear it when we reaped holders or
+  // when it points at a dead pid.
+  const ownerPid = await singletonOwnerPid(resolvedProfile);
+  if (killed.length > 0 || (ownerPid && !isAlive(ownerPid))) {
+    for (const name of ["SingletonLock", "SingletonCookie", "SingletonSocket"]) {
+      await fs.rm(path.join(resolvedProfile, name), { force: true })
+        .catch(() => {});
+    }
+  }
+
+  return { killed };
+}
+
 export async function acquireCdpProfileLock(profileDir, {
   ownerPid = process.pid,
   isAlive = isProcessAlive,

package/src/browser/chatgpt-web-adapter.js

@@ -42,6 +42,22 @@ function hasCompleteAgentEnvelope(text) {
   return start >= 0 && end >= start;
 }
 
+function sameConversationUrl(left, right) {
+  try {
+    const leftUrl = new URL(left);
+    const rightUrl = new URL(right);
+    return leftUrl.origin === rightUrl.origin
+      && leftUrl.pathname === rightUrl.pathname;
+  } catch {
+    return false;
+  }
+}
+
+function parseConversationTurn(value) {
+  const match = String(value ?? "").match(/^conversation-turn-(\d+)$/);
+  return match ? Number.parseInt(match[1], 10) : null;
+}
+
 export class ChatGPTWebAdapter {
   constructor({
     profileDir,
@@ -58,9 +74,9 @@ export class ChatGPTWebAdapter {
     this.context = null;
     this.cdpChrome = null;
     this.page = null;
-    this.assistantCountBeforeSend = 0;
-    this.assistantIdBeforeSend = null;
-    this.assistantTextBeforeSend = "";
+    this.assistantIdsBeforeSend = new Set();
+    this.assistantMaxTurnBeforeSend = null;
+    this.sentUserTurn = null;
     this.lastAssistantMessageId = null;
     this.lastModeSelection = null;
   }
@@ -147,7 +163,10 @@ export class ChatGPTWebAdapter {
     );
   }
 
-  async startConversation(conversationUrl = null) {
+  async startConversation(
+    conversationUrl = null,
+    { expectedAssistantMessageId = null } = {},
+  ) {
     this.#requirePage();
     let target = this.baseUrl;
     if (conversationUrl) {
@@ -162,7 +181,13 @@ export class ChatGPTWebAdapter {
       target = parsed.href;
     }
 
-    await this.page.goto(target, { waitUntil: "domcontentloaded" });
+    const reuseCurrent = Boolean(
+      conversationUrl
+      && sameConversationUrl(this.page.url(), target),
+    );
+    if (!reuseCurrent) {
+      await this.page.goto(target, { waitUntil: "domcontentloaded" });
+    }
     const composer = await this.#waitForComposer(30_000);
     if (!composer) {
       throw new BrowserAdapterError(
@@ -171,6 +196,13 @@ export class ChatGPTWebAdapter {
       );
     }
 
+    if (conversationUrl) {
+      await this.#waitForConversationHistory({
+        expectedAssistantMessageId,
+      });
+      return;
+    }
+
     if (!conversationUrl && !await this.#isFreshConversation()) {
       await this.#openNewConversation();
       const freshComposer = await this.#waitForComposer(30_000);
@@ -321,17 +353,15 @@ export class ChatGPTWebAdapter {
     }
 
     const assistantMessages = this.#assistantMessages();
-    this.assistantCountBeforeSend = await assistantMessages.count();
-    if (this.assistantCountBeforeSend > 0) {
-      const lastAssistant = assistantMessages.last();
-      this.assistantIdBeforeSend = await lastAssistant
-        .getAttribute("data-message-id")
-        .catch(() => null);
-      this.assistantTextBeforeSend = await this.#assistantText(lastAssistant);
-    } else {
-      this.assistantIdBeforeSend = null;
-      this.assistantTextBeforeSend = "";
-    }
+    const assistantBaseline = await this.#captureMessageIdentities(
+      assistantMessages,
+    );
+    const userBaseline = await this.#captureMessageIdentities(
+      this.#userMessages(),
+    );
+    this.assistantIdsBeforeSend = assistantBaseline.ids;
+    this.assistantMaxTurnBeforeSend = assistantBaseline.maxTurn;
+    this.sentUserTurn = null;
 
     try {
       await composer.fill(text);
@@ -367,6 +397,7 @@ export class ChatGPTWebAdapter {
       ).catch(() => null);
     }
 
+    await this.#waitForSentUserMessage(userBaseline);
     return { attachment };
   }
 
@@ -433,15 +464,30 @@ export class ChatGPTWebAdapter {
       const candidateId = lastMessage
         ? await lastMessage.getAttribute("data-message-id").catch(() => null)
         : null;
-      const hasNewAssistant = count > this.assistantCountBeforeSend
-        || (
-          candidateId
-          && candidateId !== this.assistantIdBeforeSend
-        )
-        || (
-          candidateText
-          && candidateText !== this.assistantTextBeforeSend
-        );
+      const candidateTurn = lastMessage
+        ? await this.#messageTurn(lastMessage)
+        : null;
+      let hasNewAssistant;
+      if (this.sentUserTurn != null && candidateTurn != null) {
+        // Strongest boundary: the answer must be a conversation turn after
+        // the exact user message that sendMessage() observed in the DOM.
+        hasNewAssistant = candidateTurn > this.sentUserTurn;
+      } else if (candidateId) {
+        // Stable ChatGPT message IDs are the next-best boundary. Never accept
+        // an ID that existed before this send, even if its text or DOM position
+        // changed during hydration.
+        hasNewAssistant = !this.assistantIdsBeforeSend.has(candidateId);
+      } else if (
+        candidateTurn != null
+        && this.assistantMaxTurnBeforeSend != null
+      ) {
+        hasNewAssistant = candidateTurn > this.assistantMaxTurnBeforeSend;
+      } else {
+        // Without a stable message ID or turn boundary we cannot prove this
+        // reply belongs to the current send. Timing/count heuristics caused the
+        // stale-answer bug, so fail closed and let the bounded wait time out.
+        hasNewAssistant = false;
+      }
 
       if (hasNewAssistant) {
         sawAssistant = true;
@@ -563,6 +609,124 @@ export class ChatGPTWebAdapter {
     return this.page.locator('[data-message-author-role="assistant"]');
   }
 
+  #userMessages() {
+    return this.page.locator('[data-message-author-role="user"]');
+  }
+
+  async #messageTurn(message) {
+    if (typeof message?.evaluate !== "function") {
+      return null;
+    }
+    const testId = await message.evaluate((element) => (
+      element.closest('[data-testid^="conversation-turn-"]')
+        ?.getAttribute("data-testid") ?? null
+    )).catch(() => null);
+    return parseConversationTurn(testId);
+  }
+
+  async #messageIdentity(message) {
+    const [id, turn] = await Promise.all([
+      message.getAttribute("data-message-id").catch(() => null),
+      this.#messageTurn(message),
+    ]);
+    return { id, turn };
+  }
+
+  async #captureMessageIdentities(messages) {
+    const count = await messages.count().catch(() => 0);
+    const ids = new Set();
+    let maxTurn = null;
+    for (let index = 0; index < count; index += 1) {
+      const identity = await this.#messageIdentity(messages.nth(index));
+      if (identity.id) {
+        ids.add(identity.id);
+      }
+      if (identity.turn != null) {
+        maxTurn = maxTurn == null
+          ? identity.turn
+          : Math.max(maxTurn, identity.turn);
+      }
+    }
+    return { count, ids, maxTurn };
+  }
+
+  async #waitForSentUserMessage(baseline, attempts = 50) {
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      const messages = this.#userMessages();
+      const count = await messages.count().catch(() => 0);
+      for (let index = count - 1; index >= 0; index -= 1) {
+        const identity = await this.#messageIdentity(messages.nth(index));
+        const newByTurn = identity.turn != null
+          && (
+            baseline.maxTurn == null
+            || identity.turn > baseline.maxTurn
+          );
+        const newById = Boolean(
+          identity.id
+          && !baseline.ids.has(identity.id),
+        );
+        if (newByTurn || newById) {
+          this.sentUserTurn = identity.turn;
+          return identity;
+        }
+      }
+      await this.page.waitForTimeout(100);
+    }
+    return null;
+  }
+
+  async #waitForConversationHistory({
+    expectedAssistantMessageId = null,
+    attempts = 60,
+  } = {}) {
+    let previousSignature = null;
+    let stableChecks = 0;
+
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      const assistant = await this.#captureMessageIdentities(
+        this.#assistantMessages(),
+      );
+      if (
+        expectedAssistantMessageId
+        && assistant.ids.has(expectedAssistantMessageId)
+      ) {
+        return;
+      }
+
+      if (!expectedAssistantMessageId) {
+        const totalMessages = await this.#conversationMessages()
+          .count()
+          .catch(() => 0);
+        const signature = [
+          totalMessages,
+          assistant.count,
+          assistant.maxTurn ?? "",
+          [...assistant.ids].join(","),
+        ].join(":");
+        if (totalMessages > 0 && signature === previousSignature) {
+          stableChecks += 1;
+          if (stableChecks >= 3) {
+            return;
+          }
+        } else {
+          stableChecks = 0;
+          previousSignature = signature;
+        }
+      }
+
+      await this.page.waitForTimeout(250);
+    }
+
+    await this.#writeDiagnostics("conversation-history-mismatch");
+    const detail = expectedAssistantMessageId
+      ? ` Expected assistant message ${expectedAssistantMessageId} was not found.`
+      : " Existing conversation history did not become stable.";
+    throw new BrowserAdapterError(
+      `ChatGPT conversation history could not be verified.${detail}`,
+      { code: "CONVERSATION_HISTORY_MISMATCH" },
+    );
+  }
+
   async #assistantText(message) {
     // ChatGPT may render the model's XML inside one of several code blocks,
     // alongside rich cards (weather, charts, etc.) or other markdown. Search

package/src/browser/fake-web-model-adapter.js

@@ -9,6 +9,7 @@ export class FakeWebModelAdapter {
     this.lastAssistantMessageId = null;
     this.responseNumber = 0;
     this.startConversationCalls = [];
+    this.startConversationOptions = [];
     this.sentAttachments = [];
     // Records window-state calls so tests can assert restore/minimize ordering.
     this.windowStateCalls = [];
@@ -36,8 +37,9 @@ export class FakeWebModelAdapter {
 
   async waitForManualLogin() {}
 
-  async startConversation(conversationUrl = null) {
+  async startConversation(conversationUrl = null, options = {}) {
     this.startConversationCalls.push(conversationUrl);
+    this.startConversationOptions.push(options);
     if (conversationUrl) {
       this.conversationUrl = conversationUrl;
     } else {

package/src/cli/main.js

@@ -575,7 +575,7 @@ async function runExport(sessionId, options) {
 const program = new Command()
   .name("wtagent")
   .description("Turn your web AI session into a local tool-using agent.")
-  .version("0.1.0-alpha.1")
+  .version("0.1.0-alpha.2")
   .option("--home <path>", "Application data directory")
   .option("--profile-dir <path>", "Dedicated Chrome profile directory")
   .option("--chrome-path <path>", "Chrome/Chromium executable")

package/src/cli/render-events.js

@@ -64,6 +64,10 @@ export class Renderer {
     // line so the several completion-shaped events never double-print.
     this.handled = new Set();
     this.toolStart = new Map();
+    // A renderer lives for the whole interactive CLI session. Runtime turns
+    // still emit lifecycle events when they resume the same web conversation,
+    // but those milestones are only useful on the first turn.
+    this.lifecycleShown = new Set();
   }
 
   // ---- spinner -----------------------------------------------------------
@@ -251,6 +255,10 @@ export class Renderer {
     const { type, payload = {} } = event ?? {};
     switch (type) {
       case "browser.started":
+        if (this.lifecycleShown.has(type)) {
+          break;
+        }
+        this.lifecycleShown.add(type);
         this.status("Chrome started.");
         break;
       case "browser.auth_required":
@@ -272,6 +280,10 @@ export class Renderer {
         break;
       }
       case "conversation.started":
+        if (this.lifecycleShown.has(type)) {
+          break;
+        }
+        this.lifecycleShown.add(type);
         if (payload.mode) {
           this.status(`Conversation ready (${payload.mode}).`);
         } else {

package/src/runtime/agent-runtime.js

@@ -198,10 +198,19 @@ export class AgentRuntime {
       await this.emit("browser.authenticated");
     }
 
-    await this.adapter.startConversation(resume ? previousConversationUrl : null);
+    await this.adapter.startConversation(
+      resume ? previousConversationUrl : null,
+      {
+        expectedAssistantMessageId: resume
+          ? this.session.state.lastAssistantMessageId
+          : null,
+      },
+    );
     // The actual mode may differ from the requested one (Pro limited, fallback,
     // or switcher not found), so report what was really selected.
-    let activeMode = mode;
+    let activeMode = resume
+      ? (this.session.state.activeMode ?? null)
+      : null;
     if (!resume) {
       const modeResult = await this.adapter.selectMode(mode);
       if (modeResult) {
@@ -226,6 +235,7 @@ export class AgentRuntime {
     await this.session.update({
       phase: "running",
       conversationUrl: await this.adapter.getConversationUrl(),
+      activeMode,
     });
     await this.emit("conversation.started", {
       url: this.session.state.conversationUrl,
@@ -251,6 +261,14 @@ export class AgentRuntime {
         initialTranscript = [userMessage(instruction, messageOptions)];
       }
       initialKind = "pending_tool_result";
+    } else if (resume && instruction?.trim()) {
+      // The live ChatGPT conversation already contains the bootstrap protocol
+      // and tool catalog. A normal follow-up should be the user's message, not
+      // another several-thousand-character protocol bootstrap. sendMessage()
+      // still appends the short format reminder.
+      initialMessage = instruction.trim();
+      initialTranscript = [userMessage(instruction.trim(), messageOptions)];
+      initialKind = "follow_up";
     } else if (resume) {
       const prompt = buildResumePrompt({
         instruction,
@@ -302,16 +320,22 @@ export class AgentRuntime {
           });
         },
       });
+      const assistantMessageId = await this.adapter
+        .getLastAssistantMessageId?.() ?? null;
       if (awaitingPendingAcknowledgement) {
         await this.session.clearPendingToolResult();
         awaitingPendingAcknowledgement = false;
       }
       await this.session.update({
         conversationUrl: await this.adapter.getConversationUrl(),
+        // Null is meaningful: retaining an older ID would falsely prove only
+        // that stale history had hydrated on the next resume.
+        lastAssistantMessageId: assistantMessageId,
       });
       await this.emit("model.message_complete", {
         turn: turnNumber,
         raw,
+        assistantMessageId,
       });
 
       let parsed;
@@ -391,8 +415,6 @@ export class AgentRuntime {
         continue;
       }
 
-      const assistantMessageId = await this.adapter
-        .getLastAssistantMessageId?.() ?? null;
       const identity = deriveToolIdentity({
         sessionId: this.session.sessionId,
         assistantMessageId,

package/src/session/agent-session.js

@@ -179,6 +179,8 @@ export class AgentSession {
       turn: 0,
       runCount: 0,
       conversationUrl: null,
+      lastAssistantMessageId: null,
+      activeMode: null,
       createdAt: now,
       updatedAt: now,
       rolloutFile: rolloutFileName(now, sessionId),
@@ -243,6 +245,8 @@ export class AgentSession {
       ? "idle"
       : (state.status ?? "idle");
     state.runCount ??= 0;
+    state.lastAssistantMessageId ??= null;
+    state.activeMode ??= null;
     state.rolloutFile ??= "transcript.jsonl";
     state.lastMessage ??= state.finalMessage ?? null;
     state.completedTools ??= {};