@tomflow/chatloop-extension 0.0.0-stage → 0.3.28

package/extension/clock.html

@@ -0,0 +1,4 @@
+<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><title>Chat Loop · Controlled Clock Test</title>
+<style>body{font:15px system-ui,sans-serif;margin:24px;max-width:640px}#status{font-weight:bold}#details{white-space:pre-wrap}</style></head><body>
+<h1>Chat Loop · Acceptance Clock</h1><p id="status">VERIFYING</p><p id="details">只允许扩展拥有的验收会话：在 RUNNING 时跨越受控边界，或真实已运行20分钟后缩短墙钟测试；不直接发送消息。</p>
+<script src="actions/clock.js"></script></body></html>

package/extension/content.js

@@ -0,0 +1,40 @@
+// Read-only ChatGPT page agent. Reinjection after extension reload is idempotent.
+(() => {
+if (globalThis.__CHAT_LOOP_EYE_V1__) return;
+globalThis.__CHAT_LOOP_EYE_V1__ = true;
+const CONTRACT = "chat-loop.web-environment.v1";
+const READ_CONTRACT = "chat-loop.eye.v1";
+const onChatGPT = () => location.protocol === "https:" && location.hostname === "chatgpt.com";
+
+function inspectChatPage() {
+  const brands = navigator.userAgentData?.brands;
+  const chromeBrowser = Array.isArray(brands)
+    && brands.some(entry => entry?.brand === "Google Chrome");
+  return {
+    contract: CONTRACT,
+    status: !onChatGPT() ? "UNSUPPORTED_PAGE" : !chromeBrowser
+      ? "BROWSER_UNVERIFIED" : "WEB_READY",
+    pageOrigin: onChatGPT() ? "https://chatgpt.com" : null,
+    browser: chromeBrowser ? "GOOGLE_CHROME" : "UNVERIFIED",
+    extensionVersion: chrome.runtime.getManifest().version
+  };
+}
+
+chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+  if (message?.type === "CHAT_LOOP_WEB_CHECK_V1") {
+    sendResponse(inspectChatPage());
+    return false;
+  }
+  if (message?.type !== "CHAT_LOOP_EYE_READ_V1") return false;
+  if (!onChatGPT() || !["dom", "text"].includes(message.mode)) {
+    sendResponse({contract: READ_CONTRACT, status: "UNSUPPORTED"});
+    return false;
+  }
+  const value = message.mode === "dom"
+    ? document.documentElement.outerHTML
+    : (document.querySelector("main")?.innerText ?? document.body?.innerText ?? "");
+  sendResponse({contract: READ_CONTRACT, status: "OK",
+    mode: message.mode, url: location.href, value, length: value.length});
+  return false;
+});
+})();

package/extension/continue.html

@@ -0,0 +1,9 @@
+<!doctype html>
+<html lang="zh-CN"><head><meta charset="utf-8"><title>Chat Loop Extension · Continue Action</title>
+<style>body{font:15px system-ui,sans-serif;padding:24px;max-width:620px;color:#222}#status{font-weight:bold}#details{white-space:pre-wrap;overflow-wrap:anywhere}body[data-result="error"] #status{color:#b00020}</style>
+</head><body>
+<h1>Chat Loop · Continue</h1>
+<p id="status" role="status">STARTING</p>
+<p id="details">仅执行一次已授权的固定续接。失败时保留本页，不重新发送。</p>
+<script src="actions/continue.js"></script>
+</body></html>

package/extension/dom.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<title>Chat Loop Extension · DOM</title>
+<style>body{font:15px system-ui,sans-serif;padding:24px;max-width:620px;color:#222}
+#status{font-weight:700}#details{white-space:pre-wrap;overflow-wrap:anywhere;color:#555}
+body[data-result="error"] #status{color:#b00020}</style>
+</head>
+<body>
+<h1>Chat Loop · DOM</h1>
+<p id="status" role="status">STARTING</p>
+<p id="details">正在执行，成功后关闭此页面；失败则保留错误以供诊断。</p>
+<script src="actions/common.js"></script>
+<script src="actions/dom.js"></script>
+</body>
+</html>

package/extension/handoff.html

@@ -0,0 +1,9 @@
+<!doctype html>
+<html lang="zh-CN"><head><meta charset="utf-8"><title>Chat Loop · Handoff Action</title>
+<style>body{font:15px system-ui,sans-serif;padding:24px;max-width:620px}#status{font-weight:700}#details{white-space:pre-wrap;overflow-wrap:anywhere}body[data-result="error"] #status{color:#b00020}</style>
+</head><body>
+<h1>Chat Loop · Handoff</h1>
+<p id="status" role="status">STARTING</p>
+<p id="details">仅在旧 Chat 已完成并给出明确交接包时，创建一次新 Chat 并发送一次。未知结果禁止重试。</p>
+<script src="actions/handoff.js"></script>
+</body></html>

package/extension/loop/core.js

@@ -0,0 +1,37 @@
+// Deterministic protocol primitives. No backend, model call, or business interpretation.
+(() => {
+  const MARKER = /^\[CHAT_LOOP_STATUS:(CONTINUE|DONE|BLOCKED|HANDOFF)\]$/;
+  const ALL_MARKERS = /\[CHAT_LOOP_STATUS:(?:CONTINUE|DONE|BLOCKED|HANDOFF)\]/g;
+  function parseStatus(text) {
+    if (typeof text !== "string") return "UNKNOWN";
+    const lines = text.trim().split(/\r?\n/);
+    const match = MARKER.exec(lines.at(-1)?.trim() || "");
+    if (!match) return "UNKNOWN";
+    const markers = text.match(ALL_MARKERS) || [];
+    // A portable handoff packet may legitimately quote DONE/CONTINUE rules for
+    // the next Chat. Only its final HANDOFF token must be unique; all other
+    // statuses still require a single marker in the entire reply.
+    if (match[1] === "HANDOFF") {
+      return markers.filter(v => v === "[CHAT_LOOP_STATUS:HANDOFF]").length === 1
+        ? "HANDOFF" : "UNKNOWN";
+    }
+    if (markers.length !== 1) return "UNKNOWN";
+    return match[1];
+  }
+  function fingerprint(text) {
+    let hash = 2166136261;
+    for (let i = 0; i < text.length; i++) {
+      hash ^= text.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16) + ":" + text.length;
+  }
+  function decision(status, wasConfirming = false) {
+    if (status === "DONE") return "COMPLETED";
+    if (status === "BLOCKED") return "BLOCKED";
+    if (status === "CONTINUE") return "CONTINUE";
+    if (status === "HANDOFF") return "HANDOFF";
+    return wasConfirming ? "BLOCKED" : "CONFIRM";
+  }
+  globalThis.ChatLoopCoreV1 = Object.freeze({parseStatus, fingerprint, decision});
+})();

package/extension/loop/observer.js

@@ -0,0 +1,440 @@
+// Read-only ChatGPT Turn observation. No composer writes, clicks, or task decisions.
+// Candidate DOM selectors must be verified against an authorized real ChatGPT tab.
+(() => {
+  if (globalThis.__CHAT_LOOP_OBSERVER_V1__) return;
+  globalThis.__CHAT_LOOP_OBSERVER_V1__ = true;
+  const CONTRACT = "chat-loop.turn-observer.v1";
+  const STABLE_MS = 2200;
+  const POLL_MS = 60_000; // Temporary: check Turn status once per minute, independent of Handoff clock.
+  const session = {
+    path: "", baselineUser: null, baselineAssistant: null,
+    pendingUser: null, completedUser: null,
+    candidate: "", stableSince: 0, firstSendSeen: false, firstSendAt: 0,
+    sawHomepage: false, attaching: false, attachingFirstTurn: false,
+    priorUser: null, attachSignature: "", attachSince: 0,
+    emittedCount: 0, firstTurnAt: 0, reportedErrorUser: null
+  };
+  let state = {contract: CONTRACT, status: "UNKNOWN", reason: "INITIALIZING", eventCount: 0};
+
+  const conversationPath = () => {
+    if (location.protocol !== "https:" || location.hostname !== "chatgpt.com") return "";
+    const path = location.pathname.replace(/\/$/, "");
+    return /^\/(?:c\/[0-9a-f-]{12,}|g\/[^/]+\/c\/[0-9a-f-]{12,})$/i.test(path)
+      ? path : "";
+  };
+  function visible(el) {
+    if (!el || !el.getClientRects?.().length) return false;
+    if (el.closest?.('[hidden],[aria-hidden="true"]')) return false;
+    const style = globalThis.getComputedStyle?.(el);
+    return style?.display !== "none" && style?.visibility !== "hidden";
+  }
+  function messageId(node, role) {
+    if (!node) return null;
+    const container = node.closest?.('[data-testid^="conversation-turn-"]');
+    const ids = node.getAttribute?.("data-chatgpt-search-message-ids") || "";
+    const id = node.getAttribute?.("data-message-id")
+      || ids.trim().split(/\s+/)[0] || container?.getAttribute?.("data-testid");
+    return id ? role + ":" + id : null;
+  }
+  function fingerprint(text) {
+    let hash = 2166136261;
+    for (const char of text) {
+      hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+    }
+    return (hash >>> 0).toString(16) + ":" + text.length;
+  }
+  function inspect() {
+    const path = conversationPath();
+    if (!path) return {path: "", unavailable: "CHAT_NOT_IDENTIFIED"};
+    // ChatGPT can keep multiple conversation <main> nodes in the DOM;
+    // only the currently rendered one may supply Turn identity or status.
+    const mains = [...document.querySelectorAll("main")].filter(visible);
+    if (mains.length !== 1) return {path,
+      unavailable: mains.length ? "MAIN_AMBIGUOUS" : "MAIN_UNAVAILABLE"};
+    const main = mains[0];
+    const legacy = [...main.querySelectorAll(
+      '[data-message-author-role="user"],[data-message-author-role="assistant"]')];
+    const roles = legacy.length ? legacy : [...main.querySelectorAll(
+      '[data-chatgpt-search-unit-key][data-chatgpt-search-message-ids]')];
+    const roleOf = el => el.getAttribute?.("data-message-author-role")
+      || el.getAttribute?.("data-chatgpt-search-unit-key")?.split(":").at(-1);
+    const userIndex = roles.findLastIndex(el => roleOf(el) === "user");
+    const lastUser = userIndex >= 0 ? roles[userIndex] : null;
+    const afterUser = roles.slice(userIndex + 1).filter(el => roleOf(el) === "assistant");
+    const lastAssistant = afterUser.at(-1) || null;
+    const lastHistoricAssistant = roles.filter(el => roleOf(el) === "assistant").at(-1);
+    const userKey = messageId(lastUser, "user");
+    const assistantKey = messageId(lastAssistant, "assistant");
+    const historicAssistantKey = messageId(lastHistoricAssistant, "assistant");
+    const scope = lastAssistant?.closest?.('[data-testid^="conversation-turn-"]')
+      || lastAssistant?.closest?.('[data-talvt-turn-state]') || lastAssistant;
+    const reply = lastAssistant?.querySelector?.(".markdown") || lastAssistant;
+    const text = (reply?.innerText ?? reply?.textContent ?? "").trim();
+    const stop = [...document.querySelectorAll(
+      'button[data-testid="stop-button"],button[aria-label="Stop generating"],' +
+      'button[aria-label="Stop"],button[aria-label="停止生成"],' +
+      'button[aria-label="停止响应"]')].some(visible);
+    const busy = afterUser.some(node => {
+      const part = node.closest?.('[data-testid^="conversation-turn-"]')
+        || node.closest?.('[data-talvt-turn-state]') || node;
+      return [...part.querySelectorAll?.('[aria-busy="true"],[data-tool-status="running"],' +
+        '[data-state="running"],[data-testid="tool-running"]') || []].some(visible);
+    });
+    const toolParts = afterUser.flatMap(node => {
+      const part = node.closest?.('[data-testid^="conversation-turn-"]')
+        || node.closest?.('[data-talvt-turn-state]') || node;
+      return [...part.querySelectorAll?.('[data-testid*="tool"],[data-tool-status]') || []];
+    });
+    const toolUnknown = toolParts.some(el => {
+      if (!visible(el)) return false;
+      if (el.matches?.('[data-tool-status="running"],[data-testid="tool-running"]')) {
+        return false;
+      }
+      const status = el.getAttribute?.("data-tool-status")
+        || el.getAttribute?.("data-state") || "";
+      // A failed/cancelled tool call can be terminal as a *tool result* while
+      // the assistant may continue and finish its own Turn. Page-level errors
+      // are handled separately by snap.fatal; never equate tool failure to
+      // a completed assistant reply.
+      return !/^(done|complete|completed|success|succeeded|finished|failed|error|cancelled|canceled)$/i.test(status)
+        && !el.matches?.('[data-testid*="tool-completed"],[data-testid*="tool-finished"]');
+    });
+    const editor = document.querySelector(
+      '#prompt-textarea[contenteditable="true"],' +
+      '[data-testid="composer-input"][contenteditable="true"],' +
+      '[contenteditable="true"][data-composer-markdown],' +
+      '[contenteditable="true"][data-placeholder]');
+    const composerReady = visible(editor) && !editor.closest?.('[aria-disabled="true"]');
+    const copyAction = scope && [...scope.querySelectorAll?.(
+      'button[data-testid="copy-turn-action-button"],' +
+      'button[aria-label="Copy"],button[aria-label="Copy response"],' +
+      'button[aria-label="复制"],button[aria-label="复制回复"]') || []].some(visible);
+    // A visible interruption banner is not a completed assistant Turn, even
+    // when a partial reply has Copy and no Stop button.
+    const errorPattern = /unknown error|something went wrong|an error occurred|unable to load|connection (?:lost|interrupted)|waiting for (?:full|complete) response|发生错误|出错了|请求失败|网络错误|连接已中断|正在等待完整答复/i;
+    const errorNodes = [...main.querySelectorAll(
+      '[role="alert"],[role="status"],[data-testid="conversation-error"],' +
+      '[data-testid*="connection-status"]')].filter(visible);
+    // Only explicit conversation/context exhaustion is eligible for error Handoff.
+    // Generic Unknown error is never evidence of a capacity limit.
+    const contextLimitPattern = /(?:conversation (?:has (?:reached|exceeded) (?:its |the )?(?:maximum|context)|is too long)|context (?:window|length|limit) (?:has been |was )?(?:exceeded|reached)|maximum conversation (?:length|limit) (?:reached|exceeded)|对话(?:上下文|长度)(?:已)?(?:达到|超过)(?:上限|限制)|上下文(?:窗口|长度)(?:已)?(?:达到|超过)(?:上限|限制))/i;
+    const contextLimit = errorNodes.some(el => contextLimitPattern.test(el.innerText ?? el.textContent ?? ""));
+    // An anti-bot/security challenge is not an ordinary generation failure.
+    // A visible native Retry is NOT permission to automate bypass attempts.
+    const securityChallenge = errorNodes.some(el =>
+      /\bcloudflare_challenge\b/i.test(el.innerText ?? el.textContent ?? ""));
+    const fatal = contextLimit || securityChallenge || errorNodes.some(el =>
+      errorPattern.test(el.innerText ?? el.textContent ?? ""));
+    const retryAvailable = !contextLimit && !securityChallenge && errorNodes.some(el =>
+      [...el.querySelectorAll?.('button') || []].some(button => visible(button)
+        && /^(?:retry|try again|重试|再试一次)$/i.test(
+          (button.innerText || button.textContent || button.getAttribute?.('aria-label') || '').trim())));
+    const dialog = [...document.querySelectorAll(
+      '[role="dialog"][aria-modal="true"],dialog[open]')].some(visible);
+    const turnState = scope?.getAttribute?.("data-talvt-turn-state") || null;
+    return {path, userKey, assistantKey, historicAssistantKey, text,
+      hasUser: Boolean(lastUser), hasAssistant: Boolean(lastAssistant),
+      stop, busy, toolUnknown, turnState, composerReady, copyAction,
+      fatal, errorReason: securityChallenge ? "SECURITY_CHALLENGE"
+        : contextLimit ? "CONTEXT_LIMIT" : "PAGE_ERROR", retryAvailable, dialog};
+  }
+  function emit(status, reason, snap, event = null) {
+    if (event) session.emittedCount += 1;
+    state = {contract: CONTRACT, status, reason, page: snap.path || null,
+      userKey: snap.userKey || null, assistantKey: snap.assistantKey || null,
+      retryAvailable: status === "BLOCKED" && snap.retryAvailable === true,
+      eventCount: session.emittedCount, observedAt: Date.now()};
+    if (event) {
+      document.dispatchEvent(new CustomEvent("CHAT_LOOP_TURN_FINISHED_V1", {
+        detail: {contract: CONTRACT, page: snap.path,
+          userKey: snap.userKey, assistantKey: snap.assistantKey}
+      }));
+      // Sensor -> extension scheduler: no composer writes or action decisions here.
+      // Only a freshly verified Turn can request autonomous scheduling.
+      if (typeof chrome.runtime.sendMessage === "function") {
+        void Promise.resolve(chrome.runtime.sendMessage({
+          type: "CHAT_LOOP_TURN_FINISHED_V1", page: snap.path,
+          userKey: snap.userKey, assistantKey: snap.assistantKey,
+          replyText: snap.text, startedAt: session.firstTurnAt || Date.now()
+        })).catch(() => {});
+      }
+    }
+    return state;
+  }
+  function resetCandidate() {
+    session.candidate = "";
+    session.stableSince = 0;
+  }
+  function poll() {
+    try {
+      const snap = inspect();
+      if (!snap.path) {
+        // Preserve a fresh homepage submit, but discard stale submit intent
+        // when leaving an already identified conversation.
+        if (session.path) session.firstSendSeen = false;
+        session.path = "";
+        session.sawHomepage = true;
+        session.attaching = false;
+        session.attachingFirstTurn = false;
+        resetCandidate();
+        return emit("UNKNOWN", snap.unavailable, snap);
+      }
+      if (snap.unavailable || snap.hasUser && !snap.userKey) {
+        resetCandidate();
+        return emit("UNKNOWN", snap.unavailable || "USER_ID_MISSING", snap);
+      }
+      if (snap.path !== session.path) {
+        const cameFromAnotherPage = Boolean(session.path) || session.sawHomepage;
+        const recentSend = !session.path && session.firstSendSeen
+          && Date.now() - session.firstSendAt <= 30000;
+        const firstTurn = recentSend && Boolean(snap.userKey);
+        session.firstSendSeen = false;
+        session.sawHomepage = false;
+        const previousUser = state.userKey || null;
+        session.path = snap.path;
+        session.baselineUser = firstTurn ? null : snap.userKey;
+        session.baselineAssistant = firstTurn ? null : snap.historicAssistantKey;
+        session.pendingUser = firstTurn ? snap.userKey : null;
+        session.completedUser = null;
+        resetCandidate();
+        session.attachingFirstTurn = recentSend && !snap.userKey;
+        // Cold content-script startup can precede historical message hydration.
+        // An empty /c/ route is not proof the conversation has no history.
+        session.attaching = !recentSend && (cameFromAnotherPage || !snap.userKey);
+        session.priorUser = cameFromAnotherPage ? previousUser : null;
+        session.attachSignature = "";
+        session.attachSince = 0;
+        if (firstTurn) return emit("RUNNING", "FIRST_CHAT_TURN_SUBMITTED", snap);
+        if (session.attachingFirstTurn) {
+          session.baselineUser = null;
+          session.baselineAssistant = null;
+          return emit("RUNNING", "WAITING_FIRST_USER", snap);
+        }
+        if (session.attaching) {
+          session.baselineUser = null;
+          session.baselineAssistant = null;
+          return emit("UNKNOWN", "ATTACHING_CHAT", snap);
+        }
+        return emit(snap.stop || snap.busy ? "UNKNOWN" : "IDLE",
+          snap.stop || snap.busy ? "ATTACHED_MID_TURN" : "BASELINE_ESTABLISHED", snap);
+      }
+
+      if (session.attachingFirstTurn) {
+        if (Date.now() - session.firstSendAt > 30000) {
+          session.firstSendSeen = false;
+          session.attachingFirstTurn = false;
+          session.attaching = true;
+          return emit("UNKNOWN", "FIRST_USER_NOT_CONFIRMED", snap);
+        }
+        if (!snap.userKey) return emit("RUNNING", "WAITING_FIRST_USER", snap);
+        session.firstSendSeen = false;
+        session.attachingFirstTurn = false;
+        session.pendingUser = snap.userKey;
+        return emit("RUNNING", "FIRST_CHAT_TURN_SUBMITTED", snap);
+      }
+      if (session.attaching) {
+        if (!snap.userKey) return emit("UNKNOWN", "WAITING_CHAT_HYDRATION", snap);
+        if (session.priorUser && snap.userKey === session.priorUser) {
+          session.attachSignature = "";
+          return emit("UNKNOWN", "STALE_PREVIOUS_CHAT_DOM", snap);
+        }
+        if (snap.stop || snap.busy || snap.turnState && snap.turnState !== "complete") {
+          session.attachSignature = "";
+          return emit("UNKNOWN", "ATTACHED_MID_TURN", snap);
+        }
+        if (!snap.composerReady || snap.hasAssistant && !snap.assistantKey) {
+          session.attachSignature = "";
+          return emit("UNKNOWN", "ATTACHING_CHAT", snap);
+        }
+        const signature = snap.userKey + "|" + (snap.historicAssistantKey || "");
+        if (signature !== session.attachSignature) {
+          session.attachSignature = signature;
+          session.attachSince = Date.now();
+          return emit("UNKNOWN", "ATTACHING_CHAT", snap);
+        }
+        if (Date.now() - session.attachSince < STABLE_MS) {
+          return emit("UNKNOWN", "WAITING_CHAT_HYDRATION", snap);
+        }
+        session.attaching = false;
+        session.priorUser = null;
+        session.baselineUser = snap.userKey;
+        session.baselineAssistant = snap.historicAssistantKey;
+        session.pendingUser = null;
+        return emit("IDLE", "BASELINE_ESTABLISHED", snap);
+      }
+      if (snap.fatal || snap.dialog) {
+        resetCandidate();
+        // A visible page failure must reach the owner, not merely update the
+        // content-script's local status. Report once for the specific pending
+        // user Turn; Worker independently verifies the same error twice.
+        if (snap.fatal && snap.userKey && snap.userKey !== session.completedUser
+          && (snap.userKey === session.pendingUser
+            || session.baselineUser && snap.userKey !== session.baselineUser)
+          && session.reportedErrorUser !== snap.userKey) {
+          session.reportedErrorUser = snap.userKey;
+          void Promise.resolve(chrome.runtime.sendMessage({
+            type: "CHAT_LOOP_TURN_BLOCKED_V1", page: snap.path,
+            userKey: snap.userKey, reason: snap.errorReason,
+            retryAvailable: snap.retryAvailable === true
+          })).catch(() => {});
+        }
+        return emit(snap.fatal ? "BLOCKED" : "UNKNOWN",
+          snap.fatal ? snap.errorReason : "MODAL_PRESENT", snap);
+      }
+      if (!snap.userKey || snap.userKey === session.baselineUser
+        && session.pendingUser === null) {
+        return emit("IDLE", "NO_NEW_USER_TURN", snap);
+      }
+      if (snap.userKey === session.completedUser) {
+        return emit("IDLE", "TURN_ALREADY_EMITTED", snap);
+      }
+      if (snap.userKey !== session.pendingUser) {
+        if (!session.firstTurnAt) session.firstTurnAt = Date.now();
+        session.pendingUser = snap.userKey;
+        session.candidate = "";
+        session.stableSince = 0;
+      }
+      if (snap.hasAssistant && !snap.assistantKey) {
+        resetCandidate();
+        return emit("UNKNOWN", "ASSISTANT_ID_MISSING", snap);
+      }
+      if (!snap.assistantKey || snap.assistantKey === session.baselineAssistant) {
+        return emit("RUNNING", "WAITING_FOR_NEW_ASSISTANT", snap);
+      }
+      if (snap.stop || snap.busy || snap.turnState && snap.turnState !== "complete") {
+        session.candidate = "";
+        return emit("RUNNING", snap.busy ? "TOOL_OR_ASSISTANT_BUSY" : "STOP_BUTTON_PRESENT", snap);
+      }
+      if (snap.toolUnknown) {
+        session.candidate = "";
+        return emit("UNKNOWN", "TOOL_COMPLETION_UNVERIFIED", snap);
+      }
+      if (!snap.composerReady || !snap.copyAction || !snap.text) {
+        session.candidate = "";
+        return emit("UNKNOWN", "FINAL_UI_EVIDENCE_MISSING", snap);
+      }
+      const signature = snap.userKey + "|" + snap.assistantKey + "|" + fingerprint(snap.text);
+      if (signature !== session.candidate) {
+        session.candidate = signature;
+        session.stableSince = Date.now();
+        return emit("RUNNING", "ANSWER_NOT_YET_STABLE", snap);
+      }
+      if (Date.now() - session.stableSince < STABLE_MS) {
+        return emit("RUNNING", "WAITING_FOR_STABILITY", snap);
+      }
+      session.completedUser = snap.userKey;
+      return emit("TURN_FINISHED", "EVIDENCE_CONFIRMED", snap, true);
+    } catch (error) {
+      resetCandidate();
+      return emit("UNKNOWN", "OBSERVER_EXCEPTION", {path: session.path});
+    }
+  }
+  function recordFirstChatSubmission(event) {
+    if (!event?.target?.closest) return;
+    const fromHome = !conversationPath() && !session.path;
+    const fromEmptyChat = Boolean(conversationPath()) && session.attaching
+      && !session.baselineUser && !session.attachSignature;
+    if (!fromHome && !fromEmptyChat) return;
+    const sendClick = event.type === "click" && event.target.closest(
+      'button[type="submit"][aria-label="发送"],button[data-testid="send-button"],' +
+      'button[data-testid="composer-send-button"],button[aria-label="Send message"]');
+    const sendEnter = event.type === "keydown" && event.key === "Enter"
+      && !event.shiftKey && !event.isComposing && event.target.closest(
+        '[contenteditable="true"][data-composer-markdown],#prompt-textarea');
+    if (!sendClick && !sendEnter) return;
+    const editor = document.querySelector('[contenteditable="true"][data-composer-markdown]')
+      || document.querySelector('#prompt-textarea[contenteditable="true"]');
+    if (!visible(editor) || !(editor.innerText ?? editor.textContent ?? "").trim()) return;
+    session.firstSendSeen = true;
+    session.firstSendAt = Date.now();
+    if (!session.firstTurnAt) session.firstTurnAt = session.firstSendAt;
+    if (fromEmptyChat) {
+      session.attaching = false;
+      session.attachingFirstTurn = true;
+      session.baselineUser = null;
+      session.baselineAssistant = null;
+      session.pendingUser = null;
+    }
+  }
+  document.addEventListener?.("click", recordFirstChatSubmission, true);
+  document.addEventListener?.("keydown", recordFirstChatSubmission, true);
+  globalThis.ChatLoopTurnObserverV1 = Object.freeze({
+    poll, read: () => ({...state})
+  });
+  chrome.runtime.onMessage.addListener((message, _sender, reply) => {
+    if (message?.type === "CHAT_LOOP_TURN_RETRY_MONITOR_V1") {
+      const snap = inspect();
+      if (snap.path !== message.page || snap.userKey !== message.userKey
+        || session.reportedErrorUser !== message.userKey
+        || session.completedUser === message.userKey) {
+        reply({contract: CONTRACT, status: "UNVERIFIED", reason: "RETRY_OWNER_CHANGED"});
+        return false;
+      }
+      session.reportedErrorUser = null;
+      reply({contract: CONTRACT, status: "REARMED", userKey: snap.userKey});
+      // Re-read after the Worker has committed WAITING_REPLY; if the same red
+      // error is still visible this is the second failure, not a new Continue.
+      void Promise.resolve().then(poll);
+      return false;
+    }
+    if (message?.type === "CHAT_LOOP_TURN_RESUME_V1") {
+      // Rebind only the exact Worker-owned pending Turn after extension Reload.
+      // Historical DOM by itself never authorizes a new completion event.
+      const snap = inspect();
+      if (!snap.path || snap.unavailable || snap.path !== message.page
+        || !/^user:[^\s]{8,}$/.test(message.userKey || "")
+        || snap.userKey !== message.userKey
+        || message.assistantKey && !/^assistant:[^\s]{8,}$/.test(message.assistantKey)) {
+        reply({contract: CONTRACT, status: "UNVERIFIED", reason: "RESUME_IDENTITY_MISMATCH"});
+        return false;
+      }
+      // The Worker can still be WAITING_REPLY after our completion report was
+      // lost (e.g. MV3 worker suspension). Only that Worker-owned exact Turn
+      // may request a new stable read. Never replay on ordinary DOM polling.
+      if (session.pendingUser === message.userKey && !session.attaching
+        && session.completedUser !== message.userKey) {
+        reply({contract: CONTRACT, status: "ALREADY_MONITORING"});
+        return false;
+      }
+      session.path = snap.path;
+      session.sawHomepage = false;
+      session.attaching = false;
+      session.attachingFirstTurn = false;
+      session.firstSendSeen = false;
+      session.priorUser = null;
+      session.baselineUser = null;
+      session.baselineAssistant = message.assistantKey || null;
+      session.pendingUser = message.userKey;
+      session.completedUser = null;
+      session.firstTurnAt = Number.isSafeInteger(message.startedAt)
+        && message.startedAt > 0 ? message.startedAt : Date.now();
+      session.attachSignature = "";
+      resetCandidate();
+      const observation = poll();
+      reply({contract: CONTRACT, status: "RESUMED",
+        observation: observation.status, reason: observation.reason,
+        userKey: observation.userKey});
+      return false;
+    }
+    if (message?.type === "CHAT_LOOP_TURN_VERIFY_V1") {
+      // Explicit manual Action: only a fresh read-only completed-Turn candidate.
+      // This does not emit a completion event or write anything to the page.
+      const snap = inspect();
+      const ready = Boolean(snap.path && snap.userKey && snap.assistantKey
+        && snap.text && snap.composerReady && snap.copyAction
+        && !snap.stop && !snap.busy && !snap.toolUnknown && !snap.fatal
+        && !snap.dialog && (!snap.turnState || snap.turnState === "complete"));
+      reply({contract: CONTRACT, status: ready ? "READY" : "UNVERIFIED",
+        page: snap.path || null, userKey: snap.userKey || null,
+        assistantKey: snap.assistantKey || null,
+        replyText: ready ? snap.text : null});
+      return false;
+    }
+    if (message?.type !== "CHAT_LOOP_TURN_OBSERVE_V1") return false;
+    if (message.poll === true) poll();
+    reply({...state});
+    return false;
+  });
+  setInterval(poll, POLL_MS);
+  poll();
+})();

package/extension/manifest.json

@@ -0,0 +1,38 @@
+{
+  "manifest_version": 3,
+  "name": "Chat Loop Extension",
+  "version": "0.3.28",
+  "description": "Chat Loop browser companion: Eye actions, Turn observer, Continue and Handoff Actions",
+  "permissions": [
+    "activeTab",
+    "tabs",
+    "downloads",
+    "clipboardWrite",
+    "nativeMessaging",
+    "storage",
+    "alarms",
+    "scripting"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_title": "Check Chat Loop web environment",
+    "default_popup": "popup.html"
+  },
+  "content_scripts": [
+    {
+      "matches": [
+        "https://chatgpt.com/*"
+      ],
+      "js": [
+        "content.js",
+        "loop/observer.js"
+      ],
+      "run_at": "document_idle"
+    }
+  ]
+}

package/extension/popup.html

@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="zh-CN">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Chat Loop Extension · 环境检测</title>
+  <style>
+    body { font-family: system-ui, sans-serif; width: 310px; margin: 0; padding: 18px; color: #242424; }
+    h1 { font-size: 17px; margin: 0 0 12px; }
+    #status { font-size: 15px; font-weight: 650; }
+    #detail { color: #60636a; line-height: 1.5; font-size: 13px; }
+    a { color: #1269c7; }
+  </style>
+</head>
+<body>
+  <h1>Chat Loop Extension · 环境检查</h1>
+  <p id="status" role="status">正在检测…</p>
+  <p id="detail">仅检查当前页面与浏览器类型，不读取聊天内容。</p>
+  <p>打开动作页即执行，成功后自动关闭。多 Chat 标签页时请在动作页 URL 指定 <code>?tabId=...</code>。</p>
+  <p><a href="screenshot.html" target="_blank">Screenshot</a> · <a href="dom.html" target="_blank">DOM</a> · <a href="text.html" target="_blank">Text</a> · <a href="reload.html" target="_blank">Reload</a></p>
+  <p><a href="https://chatgpt.com/" target="_blank" rel="noopener noreferrer">打开 ChatGPT 网页版</a></p>
+  <p id="action-state" role="status">最近发送动作：读取中…</p>
+  <script src="popup.js"></script>
+  <script src="acceptance.js"></script>
+</body>
+</html>