@tomflow/chatloop-extension 0.3.46 → 0.3.48

package/README.md

@@ -2,13 +2,11 @@
 
 ## P0 资源生命周期（Extension Worker 唯一仲裁）
 
-`extension/loop/resources.js` 在既有 Worker 内维护持久资源索引，不引入第二浏览器驱动。正式 Action 同时最多 3 页，已登记执行 Chat 同时最多 2 页（Owner 与 Handoff successor）；新建前拒绝超限。已存在的普通 Chat、未知发送、BLOCKED 或带草稿页面不自动关闭。只对精确登记且测试 projectId 为 `cl-intent-e2e-*` 的 DONE Chat 执行空草稿、非激活、URL 未变化的 TTL 回收。用户真实任务的 Chat 不会自动删除；其配额满时安全拒绝新建，需用户确认归属后清理。机器只读 Action 最多 3 分钟后有界回收；写入 Action 仅凭匹配终态与 token 回收。资源创建/关闭/峰值/拒绝写入同一 `chat-loop.resources.v1`，Acceptance Audit 读取该记录；未知收据不补发。`ACTION_RESULT_TIMEOUT_UNVERIFIED` 为安全 BLOCKED，不是自动重试。
+`extension/loop/resources.js` 在既有 Worker 内维护持久资源索引，不引入第二浏览器驱动。正式 Action 同时最多 3 页，已登记执行 Chat 同时最多 2 页（Owner 与 Handoff successor）；新建前拒绝超限。已存在的普通 Chat、未知发送、BLOCKED 或带草稿页面不自动关闭。只对精确登记且测试 projectId 为 `cl-intent-e2e-*` 的 DONE Chat 执行空草稿、非激活、URL 未变化的 TTL 回收。用户真实任务的 Chat 不会自动删除；其配额满时安全拒绝新建，需用户确认归属后清理。机器只读 Action 最多 3 分钟后有界回收；写入 Action 仅凭匹配终态与 token 回收。资源创建/关闭/峰值/拒绝写入唯一 `chat-loop.resources.v1` 供 Worker 回溯；未知收据不补发。`ACTION_RESULT_TIMEOUT_UNVERIFIED` 为安全 BLOCKED，不是自动重试。
 
-**失败 Start 诊断（本地 0.3.45）**：首轮发送前若新 Chat 主页未就绪，Worker 保持 BLOCKED/START_SEND_UNVERIFIED；新增仅审计字段 `lastStartFailureCode` 记录安全白名单里的未就绪原因，`popup.html?audit=1` 的失败页探针只提供 DOM 就绪状态和控件存在布尔值，不读草稿/正文/密钥。它不证明页面可自动绕过挑战，也不能授权重发或清理未确认草稿。
+**运行状态与手动操作**：首轮发送前新 Chat 未就绪时 Worker 记录安全白名单内的失败码并 BLOCKED，绝不补发未知用户消息。Popup 常规环境检测和用户明确点击 Clean 仍可用，且 Clean 必须经过 Worker 同一个 Action 配额准入。原 `popup.html?audit=1`、`newTest` 与各种隐藏测试清理参数已从运行入口移除；升级时遗留的精确 audit 页仅在非活动且到期后由原有资源管理器清理。
 
-**手动入口限额**：Popup 的 Clean 点击也必须经 Worker 同一 Action 配额准入；开发验收 New Test 一次最多保留一个已登记测试/首页，不能从旁路无限创建标签。
-
-**验收边界**：源码测试不等于已安装 Chrome 实测。安装 npm 新包并 Reload 后须由正式 Extension Audit 验证 `resources` 字段及资源前后/峰值；未见该字段即表示仍在运行旧扩展。
+**验收边界**：离线源码回归不等于已安装 Chrome 真机通过；正式安装包的 Owner、资源配额及受控发送需要独立实测，不能用旧版证据替代。
 
 Chrome 扩展（9 个独立 Action，含 Status / Start）及其独立 CLI / Native Messaging Host。执行前先看 Help：
 
@@ -40,7 +38,7 @@ Run: chatloop-extension extension <command> --help
 {"projectId":"new-distinct-test","prompt":"新的独立任务","confirmed":true,"replaceBlockedSessionId":"11111111-1111-4111-a111-111111111111"}
 ```
 
-`PAGE_ERROR` 且无原生 Retry 时，Worker 仅观察最多四次；只有原用户消息 ID 未变且连续两次证明错误消失才继续观察；若回查时已经识别到同一 Turn 的可靠完成事件或已发出完成事件，则让已排队的完成回执自然结项，避免 4 秒回查窗口错误覆盖 DONE。其余情况依旧 BLOCKED。正式 `popup.html?audit=1` Audit 包含最近一条真实已核验故障的 `run.lastFaultProof`（不含正文）；若仅有页面告警而无此字段，不能宣称 Worker 实际进入了恢复分支。**不能把当前网页错误消失当成原消息未发送的证据**。
+`PAGE_ERROR` 且无原生 Retry 时，Worker 最多四次只读核实同一用户消息；只有同一 Turn 的错误消失并连续稳定，才恢复观察；仍有错误、身份变化或回执不明时 BLOCKED。`lastFaultProof` 存在当前 Owner 的持久状态中，不会把当前网页错误消失推断成“可以重发”。
 
 Clean 只清空输入框，不发送，不更改 Owner；必须指定精确标签页 ID 且验证目标。Chrome 已安装扩展不随 npm 包自动安装。本地源码与已发布 npm 版本可能不同，真实结果请看 [CURRENT](../../context/CURRENT.md)。
 
@@ -49,3 +47,8 @@ Clean 只清空输入框，不发送，不更改 Owner；必须指定精确标
 **新页准备超时策略（0.3.45）**：Start 新 Chat 编辑器只读等待约 218 秒，Handoff 新 Chat 只读等待约 234 秒，均保持一次新建/一次发送且不跳过 ChatGPT 网页验证。Start CLI 最多等待 310 秒，MCP Tools 转发最多 330 秒；Worker 对 Start/Handoff 的未确认资源等待 330 秒，其它 Action 维持 180 秒。窗口到期仍无确定回执时保留 BLOCKED，禁止自动重发。
 
 **0.3.46 Chrome pendingUrl 修复**：Worker 创建正式 Action 时，以自己刚发起的受控 Extension URL 与 Chrome 返回的数值 tabId 登记资源，不能依赖 `tabs.create` 立即返回最终 `tab.url`（它可能仅有 `pendingUrl`）。Action 自身仍需验证真实 URL、Owner、token，任何未确认发送都不得重试；代码回归覆盖过渡 tab.url 缺失但单次 Action 正常创建。
+
+**下一源码候选 0.3.48（未发行）**：Worker 内正式串行消息类型统一以显式路由表派发；各处理器自身的来源、一次性凭证和 Owner 身份校验保持不变。未重构或发布网页发送行为，真实已发行版仍见 CURRENT。
+
+
+**本次源码级熵减（仅候选、未发行）**：删除仅用于旧手动验收的 Popup 脚本、Clock Action、计数/模拟墙钟状态及其专属测试。正式 Start、Continue、Handoff 与 Observer/Owner、十分钟真实时钟、错误隔离、配额与已登记测试 Chat 的安全回收保持实现。继续/交接只能由独立 Action 单次发送，用户未发送草稿不允许清除；过往隐藏验收 URL 不再可调用。确切最新测试数量及未验证项只看 [CURRENT](../../context/CURRENT.md)。

package/bin/cli.mjs

@@ -11,7 +11,7 @@ const HELP={
   '': 'Usage: chatloop-extension <command> [options]\nCommands: capabilities, host, extension\nRun: chatloop-extension <command> --help',
   host: 'Usage: chatloop-extension host install <extension-id>\nRegisters the local Chrome Native Messaging Host (macOS).',
   extension: 'Usage: chatloop-extension extension <command>\nCommands: chat text | chat dom | chat screenshot | reload | clean <tab-id> | continue | handoff | status | start\nRun: chatloop-extension extension <command> --help',
-  'extension clean':'Usage: chatloop-extension extension clean <tab-id>\nClear only the verified ChatGPT composer. Never send or close a Chat.\nRequires exact tab id of a registered test page or the sole completed Chat Loop Owner.',
+  'extension clean':'Usage: chatloop-extension extension clean <tab-id>\nClear only the verified ChatGPT composer. Never send or close a Chat.\nMachine Clean requires the exact tab id of a terminal Chat Loop Owner; popup Clean requires a user-selected ChatGPT tab.',
   'extension continue':'Usage: chatloop-extension extension continue (JSON intent on stdin)\nSubmit next-turn text or query receipt; does not send directly.',
   'extension handoff':'Usage: chatloop-extension extension handoff (JSON intent on stdin)\nRequest early handoff or query receipt; does not transfer directly.',
   'extension status':'Usage: chatloop-extension extension status\nRead-only, verified active Web Chat status.',

package/bin/native-host.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // Chrome Native Messaging: one request per process, no persistent server.
-import {readRequest, finish, staleFailureConfirmed} from '../lib/bridge.mjs';
+import {readRequest, finish} from '../lib/bridge.mjs';
 import {readSession,writeSession} from '../lib/session-file.mjs';
 const MAX_INPUT=48*1024*1024;
 const write=obj=>{
@@ -29,10 +29,6 @@ process.stdin.on('data',chunk=>{
       write({status:'OK',session:readSession()});
     }else if(m.op==='session-sync'){
       write({status:'OK',session:writeSession(m.session,m.replaceBlockedSessionId)});
-    }else if(m.op==='stale-failure'){
-      const confirmed=staleFailureConfirmed(m.id,m.action);
-      write({status:confirmed?'STALE_FAILURE_CONFIRMED':'NOT_ELIGIBLE',
-        id:m.id,action:m.action});
     }else throw Object.assign(Error('Unknown operation'),{code:'INVALID_OPERATION'});
   }catch(e){write({status:'FAILED',code:e.code||'NATIVE_HOST_ERROR'});}
 });

package/extension/actions/clean.js

@@ -7,15 +7,12 @@ const isChat=url=>{try{const u=new URL(url);return u.origin==='https://chatgpt.c
   && (u.pathname==='/'||/^\/(?:c\/[0-9a-f-]{12,}|g\/[^/]+\/c\/[0-9a-f-]{12,})$/i.test(u.pathname));}
   catch{return false;}};
 const runKey='chat-loop.action.run.v1';
-const ownedKey='chat-loop.acceptance.owned.v1';
-function targetAuthorized(tab,run,owned,machine,own){
+function targetAuthorized(tab,run,machine,own){
   if(!isChat(tab?.url) || !Number.isSafeInteger(tab?.id))throw Error('CLEAN_TARGET_NOT_CHATGPT');
   if(tab.id===own.id)throw Error('CLEAN_SELF_TARGET');
   if(machine){
-    const testHome=tab.url==='https://chatgpt.com/' && Array.isArray(owned)
-      && owned.some(entry=>entry.id===tab.id);
     const owner=run?.tabId===tab.id && tab.url==='https://chatgpt.com'+run?.page;
-    if(!testHome&&!owner)throw Error('CLEAN_MACHINE_TARGET_NOT_OWNED');
+    if(!owner)throw Error('CLEAN_MACHINE_TARGET_NOT_OWNED');
     if(run && !['DONE','BLOCKED'].includes(run.phase))
       throw Error('CLEAN_ACTIVE_LOOP_DENIED');
   }else{
@@ -47,9 +44,6 @@ async function clear(target,machine){
         if([...document.querySelectorAll(
           'button[data-testid="stop-button"],button[aria-label="Stop generating"],button[aria-label="停止响应"]')]
           .some(visible))return {status:'TURN_STILL_RUNNING'};
-        if(expected.machine&&expected.url==='https://chatgpt.com/'
-          && main[0].querySelector('[data-chatgpt-search-message-ids],[data-message-author-role]'))
-          return {status:'TEST_HOME_HAS_MESSAGES'};
         const before=(input.innerText||input.textContent||'').trim();
         if(before){
           input.focus();
@@ -91,8 +85,8 @@ async function run(){
   }else tabId=Number(params.get('tabId'));
   try{
     const tab=await chrome.tabs.get(tabId);
-    const state=await chrome.storage.local.get([runKey,ownedKey]);
-    targetAuthorized(tab,state[runKey],state[ownedKey],machine,own);
+    const state=await chrome.storage.local.get(runKey);
+    targetAuthorized(tab,state[runKey],machine,own);
     show('RUNNING','已确认单个目标，清理其未发送文本。');
     const result=await clear(tab,machine);
     if(machine){

package/extension/actions/common.js

@@ -134,6 +134,29 @@ function copyText(value) {
     if (!tab?.id) throw Error("ACTION_TAB_UNVERIFIED");
     return tab;
   }
+  // Text and DOM share the same verified read path. Their separate pages
+  // select a fixed mode and clipboard settling delay; no extra executor.
+  async function runReadAction(mode, clipboardMs) {
+    const action="chat_"+mode;
+    try {
+      const machine=await machineBinding(action);
+      const own=requireOwnTab(await chrome.tabs.getCurrent());
+      const target=machine ? await machineTarget(machine) : await findTarget(own);
+      show("RUNNING", mode+" → ChatGPT tab "+target.id);
+      const value=await readChat(target,mode);
+      if(!value.length)throw Error("EMPTY_CONTENT");
+      if(machine)await machineResult(machine,value);
+      else {
+        copyText(value);
+        await new Promise(resolve=>setTimeout(resolve,clipboardMs));
+      }
+      await done(own,mode,target);
+    }catch(error){
+      await machineFailure(action,error);
+      fail(error.message || "UNEXPECTED_ERROR",
+        "操作未完成；动作页已保留，未对其他 ChatGPT 标签页进行操作。");
+    }
+  }
   function done(ownTab, action, target) {
     show("SUCCESS", action + " completed for tab " + target.id);
     document.body.dataset.result = "success";
@@ -141,6 +164,6 @@ function copyText(value) {
   }
   globalThis.ChatLoopActionCommonV1 = Object.freeze({
     show, fail, findTarget, readChat, copyText, closeAction, done, requireOwnTab,
-    machineBinding, machineTarget, machineResult, machineFailure
+    machineBinding, machineTarget, machineResult, machineFailure, runReadAction
   });
 })();

package/extension/actions/continue.js

@@ -31,13 +31,9 @@ async function sendOnce(target, text) {
         || node?.closest('[data-testid^="conversation-turn-"]')?.getAttribute("data-testid");
       const user = roles.filter(node => role(node) === "user").at(-1);
       const answer = roles.filter(node => role(node) === "assistant").at(-1);
-      if (expected.testSetup) {
-        if (expected.page !== "/" || roles.length) throw Error("TEST_CHAT_NOT_EMPTY");
-      } else if ("user:" + idOf(user) !== expected.userKey
-        || "assistant:" + idOf(answer) !== expected.assistantKey) {
+      if ("user:" + idOf(user) !== expected.userKey
+        || "assistant:" + idOf(answer) !== expected.assistantKey)
         throw Error("TURN_IDENTITY_CHANGED");
-      }
-      if (!expected.testSetup) {
       const scope = answer.closest('[data-testid^="conversation-turn-"]')
         || answer.closest('[data-talvt-turn-state]') || answer;
       const replyText = (answer.querySelector('.markdown')?.innerText || answer.innerText || '').trim();
@@ -52,50 +48,13 @@ async function sendOnce(target, text) {
         throw Error("GENERATION_STILL_RUNNING");
       if (![...scope.querySelectorAll('button[aria-label="复制"],button[aria-label="Copy"],button[data-testid="copy-turn-action-button"]')].some(visible))
         throw Error("FINAL_UI_EVIDENCE_MISSING");
-      }
       let input = document.querySelector('[contenteditable="true"][data-composer-markdown]')
         || document.querySelector('#prompt-textarea[contenteditable="true"]')
         || document.querySelector('[data-testid="composer-input"][contenteditable="true"]');
       if (!visible(input) || input.closest('[aria-disabled="true"]'))
         throw Error("COMPOSER_UNAVAILABLE");
-      if ((input.innerText || input.textContent || '').trim()) {
-        const draft = (input.innerText || input.textContent || '').trim();
-        if (!expected.testSetup || !expected.discardDraft
-          || !(draft.includes("LOOP-V037-FAST-3C1H") || (draft.startsWith("你正在接手上一 Chat 未完成的任务。旧 Chat 的网页历史仍可核实")
-    && draft.includes("【交接参考：只读网页片段，可能截断】")
-    && draft.includes("【原始任务用户消息】")
-    && draft.includes("【最近轮次证据】")
-    && draft.endsWith("是否跨 Chat 由扩展决定，不要主动要求 Handoff。")
-    && draft.length >= 450 && draft.length <= 8192))
-          || !((draft.startsWith("这是 Chat Loop 短轮回归专用测试")
-              && draft.length >= 150 && draft.length <= 800)
-            || (draft.startsWith("你正在接手上一 Chat 尚未完成的同一个任务")
-              && draft.length >= 450 && (draft.length <= 2000
-                || (draft.length <= 8192 && draft.includes("【原始任务用户消息】")
-                  && draft.includes("【最近轮次证据】"))))
-            || (draft.startsWith("你正在接手上一 Chat 未完成的任务。旧 Chat 的网页历史仍可核实")
-              && draft.includes("【原始任务用户消息】") && draft.includes("【最近轮次证据】")
-              && draft.endsWith("是否跨 Chat 由扩展决定，不要主动要求 Handoff。")
-              && draft.length >= 450 && draft.length <= 8192)
-            || (draft.startsWith("这是 Chat Loop 的长回复与一小时边界隔离测试")
-              && draft.includes("MODE-TIMED-1H") && draft.length >= 350 && draft.length <= 800)
-            || (draft.startsWith("这是 Chat Loop 的墙钟边界隔离测试")
-              && draft.includes("MODE-WALL-10M") && draft.endsWith("WALL-CLOCK-TEST。")
-              && draft.length >= 250 && draft.length <= 800)))
-          throw Error("COMPOSER_NOT_EMPTY");
-        // Explicit test preparation on the caller-created empty Chat only.
-        // Never clear the source Chat or use this branch for normal continuation.
-        input.focus();
-        const range = document.createRange();
-        range.selectNodeContents(input);
-        const selection = window.getSelection();
-        selection.removeAllRanges();
-        selection.addRange(range);
-        if (!document.execCommand("delete", false)) throw Error("TEST_DRAFT_CLEAR_REJECTED");
-        await new Promise(resolve => setTimeout(resolve, 500));
-        if ((input.innerText || input.textContent || '').trim())
-          throw Error("TEST_DRAFT_CLEAR_UNVERIFIED");
-      }
+      if ((input.innerText || input.textContent || '').trim())
+        throw Error("COMPOSER_NOT_EMPTY");
       input.focus();
       if (!document.execCommand("insertText", false, instruction)) throw Error("INPUT_NOT_ACCEPTED");
       // DOM writes can precede React composer state. Do not click a stale
@@ -124,9 +83,7 @@ async function sendOnce(target, text) {
         && canonical(input.textContent) !== canonical(instruction)) throw Error("INPUT_CHANGED_BEFORE_SEND");
       button.click(); // Once, after durable PENDING commit in the worker. Never retry.
       for (let n = 0; n < 32; n++) {
-        if (expected.testSetup ? location.pathname !== "/"
-          && !/^\/c\/(?:[0-9a-f-]{12,}|local-chatgpt%3A[0-9a-f-]{36})$/i.test(location.pathname)
-          : location.pathname !== expected.page) throw Error("CHAT_PAGE_CHANGED_AFTER_SEND");
+        if (location.pathname !== expected.page) throw Error("CHAT_PAGE_CHANGED_AFTER_SEND");
         const visibleMain = [...document.querySelectorAll("main")].filter(visible);
         if (visibleMain.length !== 1) throw Error("CHAT_MAIN_CHANGED_AFTER_SEND");
         const rows = [...visibleMain[0].querySelectorAll(
@@ -140,10 +97,6 @@ async function sendOnce(target, text) {
         if (newId && 'user:' + newId !== expected.userKey
           && (canonical(message?.innerText) === canonical(instruction)
             || canonical(message?.textContent) === canonical(instruction))) {
-          if (expected.testSetup && !/^\/c\/[0-9a-f-]{12,}$/i.test(location.pathname)) {
-            await new Promise(resolve => setTimeout(resolve, 250));
-            continue;
-          }
           return {status: "SENT_CONFIRMED", newUserKey: 'user:' + newId, newPage: location.pathname};
         }
         await new Promise(resolve => setTimeout(resolve, 250));
@@ -217,24 +170,18 @@ async function run() {
   const raw = params.get("tabId") || "";
   let token = params.get("token") || "";
   let tabId = Number(raw);
-  const setup = params.get("setup") === "1";
-  if (params.has("setup") && (!setup || !raw || token)) throw Error("TEST_SETUP_PARAMETERS_INVALID");
-  if (params.has("wall") && (!setup || params.get("timed") !== "1"
-    || !["1", "2", "10m"].includes(params.get("wall")))) throw Error("TEST_WALL_PARAMETERS_INVALID");
-  if (params.has("count") && (!setup || params.get("count") !== "86"
-    || params.get("wall") !== "10m" || params.get("timed") !== "1"))
-    throw Error("COUNT_TEST_PARAMETERS_INVALID");
+  if ([...params.keys()].some(k => k !== "tabId" && k !== "token")
+    || [...params.keys()].length !== new Set(params.keys()).size)
+    throw Error("ACTION_PARAMETERS_INVALID");
   if (raw && !/^[1-9][0-9]*$/.test(raw)
     || token && !/^[0-9a-f-]{36}$/.test(token)
     || token && !raw) throw Error("ACTION_PARAMETERS_INVALID");
   const own = await chrome.tabs.getCurrent();
   if (!own?.id || own.url !== location.href) throw Error("ACTION_TAB_UNVERIFIED");
   if (!token) {
-    show("VERIFYING", setup
-      ? "测试首回合准备（不计作 Continue 验收）：核对指定空白测试 Chat，申请一次固定测试消息许可。"
-      : "手动打开 Continue：核对当前已完成的 Turn，并申请单次发送许可。");
+    show("VERIFYING", "手动打开 Continue：核对当前已完成的 Turn，并申请单次发送许可。");
     const prepared = await chrome.runtime.sendMessage({
-      type: setup ? "CHAT_LOOP_ACTION_TEST_PREPARE_V1" : "CHAT_LOOP_ACTION_MANUAL_PREPARE_V1", action: "CONTINUE",
+      type: "CHAT_LOOP_ACTION_MANUAL_PREPARE_V1", action: "CONTINUE",
       ...(raw ? {tabId} : {})
     });
     if (prepared?.status !== "PREPARED")
@@ -257,7 +204,6 @@ async function run() {
     && result.status === "RETRY_CLICKED") || final?.status !== "OK")
     throw Error(result.reason || final?.code || "ACTION_RESULT_NOT_COMMITTED");
   show("SUCCESS", permit.retryMode === "NATIVE" ? "已点击原消息的网页重试一次；没有发送新用户消息。"
-    : setup ? "测试首回合已确认；等待正式 Continue 与 Handoff 独立执行。"
     : "已确认新增一次用户消息；Action 已完成，等待下一轮 Observer。");
   await chrome.tabs.remove(own.id);
 }

package/extension/actions/dom.js

@@ -1,25 +1,2 @@
-// DOM Action: read one selected ChatGPT tab and copy its content.
-(() => {
-  const {show, fail, findTarget, readChat, copyText, done, requireOwnTab,
-    machineBinding, machineTarget, machineResult, machineFailure}
-    = globalThis.ChatLoopActionCommonV1;
-  let machine;
-  async function run() {
-    machine = await machineBinding("chat_dom");
-    const own = requireOwnTab(await chrome.tabs.getCurrent());
-    const target = machine ? await machineTarget(machine) : await findTarget(own);
-    show("RUNNING", "dom → ChatGPT tab " + target.id);
-    const value = await readChat(target, "dom");
-    if (!value.length) throw Error("EMPTY_CONTENT");
-    if(machine) await machineResult(machine,value);
-    else copyText(value);
-    // Let Chrome publish selections to macOS pasteboard before closing.
-    if(!machine) await new Promise(resolve => setTimeout(resolve, 1000));
-    await done(own, "dom", target);
-  }
-  run().catch(async error => {
-    await machineFailure("chat_dom",error);
-    fail(error.message || "UNEXPECTED_ERROR",
-      "操作未完成；动作页已保留，未对其他 ChatGPT 标签页进行操作。");
-  });
-})();
+// DOM Action: independent entrypoint; shared verified read path.
+void globalThis.ChatLoopActionCommonV1.runReadAction('dom',1000);

package/extension/actions/handoff.js

@@ -89,56 +89,22 @@ async function verifyOldChat(target, summary, mode = "EXPLICIT") {
     || execution.result.snapshot.length < 120)) throw Error("SOURCE_SNAPSHOT_UNVERIFIED");
   return execution.result.snapshot || summary;
 }
-async function waitForNewChat(tabId, allowKnownTestDraftCleanup = false) {
+// Read-only readiness of the new, strictly blank Chat home. Never clear a
+// restored human draft, even if its text resembles a historical test prompt.
+async function waitForNewChat(tabId) {
   for (let attempt = 0; attempt < 520; attempt++) {
     const tab = await chrome.tabs.get(tabId);
     if (tab.url?.startsWith("https://chatgpt.com/")) {
       try {
-        const [check] = await chrome.scripting.executeScript({target: {tabId}, func: allowTestClear => {
+        const [check] = await chrome.scripting.executeScript({target: {tabId}, func: () => {
           if (location.origin !== "https://chatgpt.com" || location.pathname !== "/") return false;
           const input = document.querySelector('[contenteditable="true"][data-composer-markdown]')
             || document.querySelector('#prompt-textarea[contenteditable="true"]');
-          if (!input?.getClientRects?.().length) return false;
-          const draft = (input.innerText || input.textContent || '').trim();
-          if (!draft) return true;
-          // An acceptance-only new Chat may restore the exact prior Chat Loop
-          // test instruction. Never discard a real user's unsent draft.
-          if (!allowTestClear || !(draft.includes("LOOP-V037-FAST-3C1H") || (draft.startsWith("你正在接手上一 Chat 未完成的任务。旧 Chat 的网页历史仍可核实")
-    && draft.includes("【交接参考：只读网页片段，可能截断】")
-    && draft.includes("【原始任务用户消息】")
-    && draft.includes("【最近轮次证据】")
-    && draft.endsWith("是否跨 Chat 由扩展决定，不要主动要求 Handoff。")
-    && draft.length >= 450 && draft.length <= 8192))
-            || !((draft.startsWith("这是 Chat Loop 短轮回归专用测试")
-                && draft.length >= 150 && draft.length <= 800)
-              || (draft.startsWith("你正在接手上一 Chat 尚未完成的同一个任务")
-                && draft.length >= 450 && (draft.length <= 2000
-                  || (draft.length <= 8192 && draft.includes("【原始任务用户消息】")
-                    && draft.includes("【最近轮次证据】"))))
-              || (draft.startsWith("你正在接手上一 Chat 未完成的任务。旧 Chat 的网页历史仍可核实")
-                && draft.includes("【原始任务用户消息】") && draft.includes("【最近轮次证据】")
-                && draft.endsWith("是否跨 Chat 由扩展决定，不要主动要求 Handoff。")
-                && draft.length >= 450 && draft.length <= 8192)
-              || (draft.startsWith("这是 Chat Loop 的长回复与一小时边界隔离测试")
-                && draft.includes("MODE-TIMED-1H") && draft.length >= 350 && draft.length <= 800)
-              || (draft.startsWith("这是 Chat Loop 的计数隔离验收")
-                && draft.includes("COUNT-86-100") && draft.endsWith("WALL-CLOCK-TEST。")
-                && draft.length >= 200 && draft.length <= 900)
-              || (draft.startsWith("这是 Chat Loop 的墙钟边界隔离测试")
-                && draft.includes("MODE-WALL-10M") && draft.endsWith("WALL-CLOCK-TEST。")
-                && draft.length >= 250 && draft.length <= 800))) return false;
-          input.focus();
-          const range = document.createRange();
-          range.selectNodeContents(input);
-          const selection = window.getSelection();
-          selection.removeAllRanges();
-          selection.addRange(range);
-          if (!document.execCommand("delete", false)) return false;
-          return !(input.innerText || input.textContent || '').trim() ? "CLEARED_TEST_DRAFT" : false;
-        }, args: [allowKnownTestDraftCleanup]});
+          return !!input?.getClientRects?.().length
+            && !(input.innerText || input.textContent || "").trim();
+        }});
         if (check?.result === true) return;
-        if (check?.result === "CLEARED_TEST_DRAFT") {await delay(600);continue;}
-      } catch { /* Only retry a read-only readiness probe, never the send. */ }
+      } catch { /* Retry only the read-only readiness probe. */ }
     }
     await delay(450);
   }
@@ -264,10 +230,6 @@ async function run() {
     // Opening a new Chat is itself a side effect; never create another on failure.
     newTab = await chrome.tabs.create({url: "https://chatgpt.com/", active: true,
       windowId: source.windowId, openerTabId: own.id});
-    const registry = (await chrome.storage.local.get("chat-loop.acceptance.owned.v1"))[
-      "chat-loop.acceptance.owned.v1"];
-    const dedicatedTest = Array.isArray(registry)
-      && registry.some(item => item.id === request.tabId);
     // Chrome may initially report about:blank while the requested home URL loads.
     let homeUrlReady=false;
     for(let i=0;i<40;i++){
@@ -279,7 +241,7 @@ async function run() {
     const registered=await chrome.runtime.sendMessage({type:'CHAT_LOOP_RESOURCE_CHAT_V1',
       action:'handoff',stage:'register',tabId:newTab.id});
     if(registered?.status!=='OK')throw Error(registered?.code||'RESOURCE_REGISTER_UNVERIFIED');
-    await waitForNewChat(newTab.id, dedicatedTest);
+    await waitForNewChat(newTab.id);
     // The observer must exist before the first user click on the new home page.
     // A successful send without an observer cannot be automatically continued.
     let observed;
@@ -306,9 +268,8 @@ async function run() {
         + permit.pendingPlan.nextPrompt
         + "\n【边界】这只是上一轮模型提出的计划，不代表用户新增批准。新 Chat 必须先核实任务状态、项目规则及已发生的副作用，不能盲目重复。"
       : "";
-    result = await sendHandoffOnce(newTab.id, permit.countMode
-      ? message + `\n\n【计数专用交接指令，优先于前面的历史引用】旧Chat已经完成数字${permit.countValue}，本轮只加1，第一行写${permit.countValue + 1}；只有到100才能在末行写 [CHAT_LOOP_STATUS:DONE]，否则末行写 [CHAT_LOOP_STATUS:CONTINUE]。不能因接班而DONE。`
-      : message + notice + checkpoint + (permit.modelTurnNote || ""));
+    result = await sendHandoffOnce(newTab.id,
+      message + notice + checkpoint + (permit.modelTurnNote || ""));
   } catch (error) {result = {status: "UNVERIFIED", reason: error.message || "HANDOFF_ERROR"};}
   const committed = await chrome.runtime.sendMessage({type: "CHAT_LOOP_ACTION_RESULT_V1", ...request,
     result: result.status, reason: result.reason,

package/extension/actions/text.js

@@ -1,25 +1,2 @@
-// TEXT Action: read one selected ChatGPT tab and copy its content.
-(() => {
-  const {show, fail, findTarget, readChat, copyText, done, requireOwnTab,
-    machineBinding, machineTarget, machineResult, machineFailure}
-    = globalThis.ChatLoopActionCommonV1;
-  let machine;
-  async function run() {
-    machine = await machineBinding("chat_text");
-    const own = requireOwnTab(await chrome.tabs.getCurrent());
-    const target = machine ? await machineTarget(machine) : await findTarget(own);
-    show("RUNNING", "text → ChatGPT tab " + target.id);
-    const value = await readChat(target, "text");
-    if (!value.length) throw Error("EMPTY_CONTENT");
-    if(machine) await machineResult(machine,value);
-    else copyText(value);
-    // Let Chrome publish selections to macOS pasteboard before closing.
-    if(!machine) await new Promise(resolve => setTimeout(resolve, 250));
-    await done(own, "text", target);
-  }
-  run().catch(async error => {
-    await machineFailure("chat_text",error);
-    fail(error.message || "UNEXPECTED_ERROR",
-      "操作未完成；动作页已保留，未对其他 ChatGPT 标签页进行操作。");
-  });
-})();
+// TEXT Action: independent entrypoint; shared verified read path.
+void globalThis.ChatLoopActionCommonV1.runReadAction('text',250);