@tomflow/chatloop-extension 0.0.0-stage → 0.3.28

package/extension/acceptance.js

@@ -0,0 +1,389 @@
+// Read-only acceptance inventory and strictly scoped test-tab lifecycle.
+(() => {
+  const q = new URLSearchParams(location.search);
+  const modes = ["audit", "newTest", "cleanup", "cleanupVerified"].filter(k => q.has(k));
+  if (!modes.length) return; // Ordinary popup remains unchanged.
+  const runKey = "chat-loop.action.run.v1";
+  const ownedKey = "chat-loop.acceptance.owned.v1";
+  const extensionOrigin = new URL(chrome.runtime.getURL("popup.html")).origin;
+  const status = document.getElementById("status");
+  const detail = document.getElementById("detail");
+  const isChat = url => /^https:\/\/chatgpt\.com\/(?:c\/[0-9a-f-]{12,}|g\/[^/]+\/c\/[0-9a-f-]{12,})?$/i.test(url || "");
+  const sleep = ms => new Promise(r => setTimeout(r, ms));
+  async function report() {
+    if (modes.length !== 1 || [...q.keys()].some(k => !modes.includes(k)))
+      throw Error("INVALID_ACCEPTANCE_PARAMS");
+    const mode = modes[0], own = await chrome.tabs.getCurrent();
+    if (!own?.id || !own.url?.startsWith(chrome.runtime.getURL("popup.html")))
+      throw Error("INVALID_ACCEPTANCE_PAGE");
+    const [state, allBeforeCleanup] = await Promise.all([
+      chrome.storage.local.get([runKey, ownedKey]), chrome.tabs.query({})
+    ]);
+    // Only an old read-only acceptance audit page may be automatically reaped.
+    // These are diagnostics, not Chat conversations or formal Action pages.
+    // Verify id, exact URL and inactive/unpinned state before closing.
+    const removedStaleAudits = [];
+    for (const item of allBeforeCleanup) {
+      if (item.id === own.id || item.active || item.pinned
+        || item.url !== chrome.runtime.getURL("popup.html?audit=1")) continue;
+      const live = await chrome.tabs.get(item.id).catch(() => null);
+      if (live && !live.active && !live.pinned && live.url === item.url) {
+        await chrome.tabs.remove(item.id);
+        removedStaleAudits.push(item.id);
+      }
+    }
+    const all = removedStaleAudits.length ? await chrome.tabs.query({}) : allBeforeCleanup;
+    const run = state[runKey] || null;
+    const owned = Array.isArray(state[ownedKey]) ? state[ownedKey] : [];
+    const audit = {at: new Date().toISOString(), mode,
+      removedStaleAuditTabs: removedStaleAudits,
+      version: chrome.runtime.getManifest().version, totalTabs: all.length,
+      otherTabCount: all.filter(t => !isChat(t.url) && !t.url?.startsWith(extensionOrigin)).length,
+      chatTabs: all.filter(t => isChat(t.url)).map(t => ({
+        id: t.id, windowId: t.windowId, url: t.url, title: t.title, active: t.active,
+        pinned: t.pinned
+      })),
+      extensionTabs: all.filter(t => t.url?.startsWith(extensionOrigin) && t.id !== own.id)
+        .map(t => ({id: t.id, windowId: t.windowId, url: t.url, title: t.title})),
+      ownedTestTabs: owned,
+      messageEvidence: {}, actionEvidence: {},
+      run: run ? Object.fromEntries(["phase", "action", "reason", "tabId", "page",
+        "sourceTabId", "sourcePage", "attemptedNewTabId", "newUserKey",
+        "userKey", "assistantKey", "startedAt", "deadlineAt", "handoffPending",
+        "handoffPendingAt", "handoffMode", "testSetup", "timedTest", "testTurnIndex",
+        "clockAdvancedAt", "clockAdvanceMinutes", "clockRunningProof",
+        "wallTestHours", "wallHoldAt", "wallReleaseAt", "wallReleasedAt",
+        "wallTestMinutes", "wallAdjustedAt", "wallOriginalReleaseAt",
+        "countMode", "countValue", "countHandoffs", "countLastSendAt", "countReleaseAt"]
+        .filter(k => run[k] !== undefined).map(k => [k, run[k]])) : null
+    };
+    if (run?.parseEvidence && owned.some(item => item.id === run.tabId || item.id === run.sourceTabId)) {
+      audit.run.parseEvidence = run.parseEvidence;
+    }
+    // Inspect only this extension's own open action pages: a failed test setup
+    // must expose a readable failure code, never trigger a second send.
+    for (const tab of audit.extensionTabs) {
+      if (!/\/(?:continue|handoff|clock|screenshot|dom|text|reload)\.html(?:\?|$)/.test(tab.url)) continue;
+      try {
+        const [read] = await chrome.scripting.executeScript({target: {tabId: tab.id},
+          func: () => ({status: document.getElementById("status")?.innerText || "",
+            details: (document.getElementById("details")?.innerText || "").slice(0, 300)})});
+        audit.actionEvidence[tab.id] = read?.result || {status: "UNAVAILABLE"};
+      } catch {audit.actionEvidence[tab.id] = {status: "PROBE_UNAVAILABLE"};}
+    }
+    // Inspect only the active run and tests created by this extension. Browser
+    // message evidence is read-only; this page never types into ChatGPT.
+    const inspectedFailedHandoff = owned.some(item => item.id === run?.tabId || item.id === run?.sourceTabId)
+      ? run?.attemptedNewTabId : null;
+    const inspectIds = [...new Set([run?.tabId, run?.sourceTabId, inspectedFailedHandoff,
+      ...owned.map(item => item.id)])]
+      .filter(id => audit.chatTabs.some(tab => tab.id === id));
+    for (const id of inspectIds) {
+      try {
+        const [read] = await chrome.scripting.executeScript({
+          target: {tabId: id},
+          func: () => {
+            const mains = [...document.querySelectorAll("main")]
+              .filter(node => node.getClientRects().length);
+            if (mains.length !== 1) return {status: "MAIN_NOT_UNIQUE"};
+            const main = mains[0];
+            let rows = [...main.querySelectorAll(
+              "[data-chatgpt-search-unit-key][data-chatgpt-search-message-ids]")];
+            if (!rows.length) rows = [...main.querySelectorAll(
+              "[data-message-author-role]")];
+            const role = node => node.getAttribute("data-message-author-role")
+              || node.getAttribute("data-chatgpt-search-unit-key")?.split(":").at(-1);
+            const idOf = node => node.getAttribute("data-message-id")
+              || node.getAttribute("data-chatgpt-search-message-ids")?.trim().split(/\s+/)[0];
+            const users = rows.filter(node => role(node) === "user").map(idOf);
+            const assistants = rows.filter(node => role(node) === "assistant").map(idOf);
+            const last = rows.filter(node => role(node) === "assistant").at(-1);
+            const editor = document.querySelector('[contenteditable="true"][data-composer-markdown]')
+              || document.querySelector('#prompt-textarea[contenteditable="true"]');
+            const editorVisible = !!editor?.getClientRects().length;
+            const draft = (editor?.innerText || editor?.textContent || "").trim();
+            const restoredTimedTestDraft = draft.includes("LOOP-V037-FAST-3C1H")
+              && draft.includes("【原始任务用户消息】") && draft.includes("【最近轮次证据】")
+              && draft.length >= 450 && draft.length <= 8192
+              && (draft.startsWith("你正在接手上一 Chat 尚未完成的同一个任务")
+                || (draft.startsWith("你正在接手上一 Chat 未完成的任务。旧 Chat 的网页历史仍可核实")
+                  && draft.endsWith("是否跨 Chat 由扩展决定，不要主动要求 Handoff。")));
+            const text = last?.querySelector(".markdown")?.innerText || last?.innerText || "";
+            const marker = text.trim().split(/\r?\n/).at(-1)?.trim();
+            return {status: "OK", url: location.href,
+              editorVisible, restoredTimedTestDraft, draftLength: draft.length,
+              draftPreview: (editor?.innerText || editor?.textContent || "").trim().slice(0, 160),
+              draftSuffix: draft.slice(-200), testMarker: draft.includes("LOOP-V037-FAST-3C1H"),
+              userCount: users.length, assistantCount: assistants.length,
+              userIds: users, assistantIds: assistants,
+              lastAssistantStatus: /^\[CHAT_LOOP_STATUS:(?:CONTINUE|DONE|BLOCKED|HANDOFF)\]$/.test(marker)
+                ? marker : null};
+          }
+        });
+        audit.messageEvidence[id] = read?.result || {status: "EMPTY_RESULT"};
+        // Only dedicated tests created by this diagnostic may expose their
+        // harmless assistant text, for verifying strict status parsing.
+        if (owned.some(item => item.id === id || (item.id === run?.sourceTabId && id === run?.tabId))) {
+          const proof = await chrome.tabs.sendMessage(id,
+            {type: "CHAT_LOOP_TURN_VERIFY_V1"}).catch(() => null);
+          audit.messageEvidence[id].observerStatus = proof?.status || "UNAVAILABLE";
+          const observed = await chrome.tabs.sendMessage(id,
+            {type: "CHAT_LOOP_TURN_OBSERVE_V1", poll: true}).catch(() => null);
+          audit.messageEvidence[id].turnObservation = observed ? {
+            status: observed.status, reason: observed.reason, page: observed.page,
+            userKey: observed.userKey, eventCount: observed.eventCount,
+            observedAt: observed.observedAt} : null;
+          audit.messageEvidence[id].observerReplyText =
+            typeof proof?.replyText === "string" ? proof.replyText.slice(0, 3000) : null;
+        }
+      } catch {
+        audit.messageEvidence[id] = {status: "PROBE_UNAVAILABLE"};
+      }
+    }
+    if (mode === "newTest") {
+      if (run && !["DONE", "BLOCKED"].includes(run.phase))
+        throw Error("ACTIVE_LOOP_OWNERSHIP");
+      const tab = await chrome.tabs.create({url: "https://chatgpt.com/", active: true,
+        windowId: own.windowId});
+      const next = [...owned, {id: tab.id, createdAt: Date.now()}];
+      await chrome.storage.local.set({[ownedKey]: next});
+      audit.newTestTabId = tab.id;
+      audit.ownedTestTabs = next;
+      // React can hydrate after Chrome reports the tab created. Do not open
+      // Continue setup until two stable, read-only home/editor probes pass.
+      let firstReadyAt = 0;
+      const deadline = Date.now() + 26000;
+      while (Date.now() < deadline) {
+        let ready = false;
+        try {
+          const live = await chrome.tabs.get(tab.id);
+          if (live.url === "https://chatgpt.com/") {
+            const [probe] = await chrome.scripting.executeScript({
+              target: {tabId: tab.id},
+              func: () => {
+                const visible = el => !!el?.getClientRects().length;
+                const mains = [...document.querySelectorAll("main")].filter(visible);
+                const editor = document.querySelector('[contenteditable="true"][data-composer-markdown]')
+                  || document.querySelector('#prompt-textarea[contenteditable="true"]');
+                const draft = (editor?.innerText || editor?.textContent || "").trim();
+                const knownTestDraft = (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 >= 450 && 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 {ready: location.href === "https://chatgpt.com/" && mains.length === 1
+                  && visible(editor) && (!draft || knownTestDraft)
+                  && !mains[0].querySelector('[data-chatgpt-search-message-ids],[data-message-author-role]'),
+                  discardTestDraft: knownTestDraft};
+              }
+            });
+            ready = probe?.result?.ready === true;
+            if (ready) audit.newTestNeedsDiscardDraft = probe.result.discardTestDraft === true;
+          }
+        } catch { /* Fail closed if the home page cannot be inspected. */ }
+        if (ready) {
+          if (firstReadyAt && Date.now() - firstReadyAt >= 2300) break;
+          if (!firstReadyAt) firstReadyAt = Date.now();
+        } else firstReadyAt = 0;
+        await sleep(500);
+      }
+      audit.newTestReady = firstReadyAt > 0 && Date.now() - firstReadyAt >= 2300;
+    } else if (mode === "cleanupVerified") {
+      // User-requested surplus Chat Loop test-tab cleanup. Never close ordinary
+      // work chats, pinned/active tabs, unknown ownership, or an in-flight run.
+      // Require BOTH a dedicated test title AND a verified test-message body.
+      const testTitle = /^(?:建会话测试|完成跨Chat验收|生成跨Chat交接包|验证跨Chat交接|确认跨 Chat 交接|跨 Chat 交接验证|验证聊天续接|验证聊天交接|确认交接完成|Chat Loop 验收|Chat Loop测试.*|Chat Loop交接测试|短轮回归测试|定时交接测试|交接测试确认)$/;
+      const testBody = /(?:Chat\s*Loop|CHAT-LOOP-ACTION-001|跨\s*Chat.{0,16}交接|验证聊天交接|验证聊天续接|ChatGPT Observer)/i;
+      const inFlight = run && !["DONE", "BLOCKED"].includes(run.phase)
+        ? new Set([run.tabId, run.sourceTabId, run.attemptedNewTabId])
+        : new Set();
+      audit.cleanedTestTabs = [];
+      audit.protectedTests = [];
+      for (const candidate of audit.chatTabs) {
+        if (!testTitle.test(candidate.title || "")) continue;
+        const reject = why => audit.protectedTests.push({id: candidate.id, reason: why});
+        if (candidate.active || candidate.pinned || inFlight.has(candidate.id)) {
+          reject("ACTIVE_PINNED_OR_IN_FLIGHT"); continue;
+        }
+        try {
+          const [proof] = await chrome.scripting.executeScript({
+            target: {tabId: candidate.id},
+            func: () => {
+              const main = document.querySelector("main");
+              if (!main) return {valid: false, reason: "NO_MAIN"};
+              let users = [...main.querySelectorAll('[data-message-author-role="user"]')];
+              if (!users.length) users = [...main.querySelectorAll('[data-chatgpt-search-unit-key$=":user"]')];
+              const text = users.slice(0, 3).map(n => n.innerText || n.textContent || "").join("\n");
+              return {valid: true, url: location.href, hasUser: users.length > 0,
+                sample: text.slice(0, 1800)};
+            }
+          });
+          const evidence = proof?.result;
+          if (!evidence?.valid || !evidence.hasUser || !testBody.test(evidence.sample)
+            || evidence.url !== candidate.url) {
+            reject("TEST_MESSAGE_NOT_VERIFIED"); continue;
+          }
+          const live = await chrome.tabs.get(candidate.id).catch(() => null);
+          if (!live || live.url !== candidate.url || live.title !== candidate.title
+            || live.active || live.pinned) {
+            reject("TAB_CHANGED_BEFORE_CLOSE"); continue;
+          }
+          await chrome.tabs.remove(candidate.id);
+          audit.cleanedTestTabs.push({id: candidate.id, url: candidate.url,
+            title: candidate.title});
+        } catch (err) {
+          reject("PROBE_OR_CLOSE_FAILED: " + (err?.message || "unknown"));
+        }
+      }
+      // Surplus ChatGPT home tabs are not historical conversations. Close only
+      // verified blank homes, or a home whose entire draft is a known exact
+      // Chat Loop acceptance test template. Never discard an arbitrary draft.
+      // Never touch a real /c/ conversation, even if its title is generic.
+      audit.cleanedEmptyHomeTabs = [];
+      audit.protectedEmptyHomeTabs = [];
+      for (const candidate of audit.chatTabs) {
+        if (candidate.url !== "https://chatgpt.com/"
+          || candidate.title !== "ChatGPT" || candidate.active || candidate.pinned
+          || inFlight.has(candidate.id)) continue;
+        try {
+          // An inactive unloaded home may deny script injection. Merely focus
+          // it once through the extension, retry read-only, then restore focus;
+          // failure must NOT become permission to close the unknown tab.
+          const inspectEmpty = () => {
+            const editor = document.querySelector("#prompt-textarea")
+              || document.querySelector('[contenteditable="true"][role="textbox"]');
+            const draft = editor?.value || editor?.innerText || editor?.textContent || "";
+            const hasMessages = !!document.querySelector(
+              'main [data-message-author-role], main [data-chatgpt-search-unit-key]');
+            const hasUploads = !!document.querySelector(
+              '[data-testid*="attachment-preview"], [data-testid*="image-preview"], [data-testid="composer-attachment"]');
+            const current = draft.trim();
+            const knownTestDraft = current.includes("LOOP-V037-FAST-3C1H")
+              && ((current.startsWith("这是 Chat Loop 短轮回归专用测试")
+                  && current.length >= 450 && current.length <= 800)
+                || (current.startsWith("你正在接手上一 Chat 尚未完成的同一个任务")
+                  && current.length >= 450 && (current.length <= 2000
+                    || (current.length <= 8192 && current.includes("【原始任务用户消息】")
+                      && current.includes("【最近轮次证据】"))))
+                || (current.startsWith("你正在接手上一 Chat 未完成的任务。旧 Chat 的网页历史仍可核实")
+                  && current.includes("【原始任务用户消息】") && current.includes("【最近轮次证据】")
+                  && current.endsWith("是否跨 Chat 由扩展决定，不要主动要求 Handoff。")
+                  && current.length >= 450 && current.length <= 8192)
+                || (current.startsWith("这是 Chat Loop 的墙钟边界隔离测试")
+                  && current.includes("MODE-WALL-10M") && current.endsWith("WALL-CLOCK-TEST。")
+                  && current.length >= 250 && current.length <= 800));
+            return {url: location.href, ready: document.readyState === "complete",
+              empty: !!editor && !current && !hasMessages && !hasUploads,
+              knownTestDraft: !!editor && knownTestDraft && !hasMessages && !hasUploads,
+              hasEditor: !!editor, draftLength: current.length,
+              hasMessages, hasUploads, title: document.title,
+              inputCount: document.querySelectorAll('textarea,[contenteditable="true"]').length};
+          };
+          let proof;
+          try {
+            [proof] = await chrome.scripting.executeScript({target: {tabId: candidate.id},
+              func: inspectEmpty});
+          } catch {
+            await chrome.tabs.update(candidate.id, {active: true});
+            await sleep(1400);
+            try {
+              [proof] = await chrome.scripting.executeScript({target: {tabId: candidate.id},
+                func: inspectEmpty});
+            } finally {
+              await chrome.tabs.update(own.id, {active: true});
+            }
+          }
+          const evidence = proof?.result;
+          const live = await chrome.tabs.get(candidate.id).catch(() => null);
+          if (evidence?.ready && (evidence.empty || evidence.knownTestDraft)
+            && evidence.url === candidate.url
+            && live?.url === candidate.url && live.title === "ChatGPT"
+            && !live.active && !live.pinned) {
+            await chrome.tabs.remove(candidate.id);
+            audit.cleanedEmptyHomeTabs.push(candidate.id);
+          } else audit.protectedEmptyHomeTabs.push({id: candidate.id,
+            reason: "NOT_VERIFIED_EMPTY", evidence, title: live?.title, url: live?.url});
+        } catch (err) { audit.protectedEmptyHomeTabs.push({id: candidate.id,
+          reason: "PROBE_FAILED", error: err?.message}); }
+      }
+      // Any previously orphaned read-only acceptance audit page may be closed;
+      // do not touch other extension action pages.
+      audit.cleanedAuditPages = [];
+      for (const item of audit.extensionTabs) {
+        if (!item.url?.startsWith(chrome.runtime.getURL("popup.html?audit=1"))) continue;
+        const live = await chrome.tabs.get(item.id).catch(() => null);
+        if (live && !live.active && !live.pinned && live.url === item.url) {
+          await chrome.tabs.remove(item.id);
+          audit.cleanedAuditPages.push(item.id);
+        }
+      }
+      const left = await chrome.tabs.query({});
+      audit.after = {totalTabs: left.length,
+        chatTabs: left.filter(t => isChat(t.url)).map(t => ({id:t.id, title:t.title, url:t.url})),
+        extensionTabs: left.filter(t => t.url?.startsWith(extensionOrigin) && t.id !== own.id)
+          .map(t => ({id:t.id, url:t.url}))};
+      await chrome.storage.local.set({[ownedKey]: owned.filter(item =>
+        !audit.cleanedTestTabs.some(cleaned => cleaned.id === item.id))});
+    } else if (mode === "cleanup") {
+      const id = Number(q.get("cleanup"));
+      const sourceOwned = owned.some(item => item.id === run?.sourceTabId);
+      const tab = Number.isSafeInteger(id) && id > 0
+        ? await chrome.tabs.get(id).catch(() => null) : null;
+      const isRunTarget = id === run?.tabId && tab?.url === "https://chatgpt.com" + run?.page;
+      const isRunSource = id === run?.sourceTabId
+        && tab?.url === "https://chatgpt.com" + run?.sourcePage;
+      const provenByRegistry = sourceOwned && isRunTarget;
+      // Historical test pair is allowed only when both the persisted DONE
+      // identity and an unmistakable dedicated-test title match.
+      const historicalTest = run?.action === "HANDOFF" && (isRunTarget || isRunSource)
+        && /^(验证聊天交接|确认交接完成)$/.test(tab?.title || "");
+      if (!tab || tab.pinned || run?.phase !== "DONE"
+        || !(provenByRegistry || historicalTest))
+        throw Error("CLEANUP_TARGET_NOT_PROVEN_OWNED_DONE_CHAT");
+      await chrome.tabs.remove(id);
+      audit.cleanedTabId = id;
+      await chrome.storage.local.set({[ownedKey]:
+        owned.filter(item => item.id !== id && item.id !== run.sourceTabId)});
+    }
+    const name = "ChatLoop/acceptance/audit-" + Date.now() + ".json";
+    const payload = JSON.stringify(audit, null, 2);
+    const id = await chrome.downloads.download({
+      url: "data:application/json;charset=utf-8," + encodeURIComponent(payload),
+      filename: name, conflictAction: "uniquify", saveAs: false
+    });
+    let complete = false;
+    for (let i = 0; i < 40; i++) {
+      const found = (await chrome.downloads.search({id}))[0];
+      if (found?.state === "complete") {complete = true; break;}
+      if (found?.state === "interrupted") break;
+      await sleep(150);
+    }
+    if (!complete) throw Error("AUDIT_DOWNLOAD_UNVERIFIED");
+    status.textContent = "ACCEPTANCE_SAVED";
+    detail.textContent = name;
+    await chrome.tabs.remove(own.id);
+  }
+  report().catch(err => {
+    status.textContent = "ACCEPTANCE_BLOCKED";
+    detail.textContent = err?.message || "UNKNOWN_ERROR";
+  });
+})();

package/extension/actions/clock.js

@@ -0,0 +1,29 @@
+// Test-only Action page. The Worker validates owned RUNNING boundary probes or an owned completed Turn before real 20m wall shortening.
+(async () => {
+  const status = document.getElementById('status');
+  const details = document.getElementById('details');
+  try {
+    const q = new URLSearchParams(location.search);
+    if ([...q.keys()].sort().join(',') !== 'minutes,tabId') throw Error('INVALID_CLOCK_PARAMS');
+    const tabId = Number(q.get('tabId'));
+    const minutes = Number(q.get('minutes'));
+    if (!Number.isSafeInteger(tabId) || tabId <= 0
+      || !Number.isSafeInteger(minutes) || minutes !== 20 && (minutes < 60 || minutes > 180))
+      throw Error('INVALID_CLOCK_RANGE');
+    const own = await chrome.tabs.getCurrent();
+    if (!own?.id || own.url !== location.href) throw Error('INVALID_CLOCK_ACTION_PAGE');
+    const result = await chrome.runtime.sendMessage({
+      type: 'CHAT_LOOP_ACCEPTANCE_CLOCK_ADVANCE_V1', tabId, minutes
+    });
+    if (!['ADVANCED_WHILE_RUNNING', 'SHORTENED_AFTER_REAL_20MIN'].includes(result?.status))
+      throw Error(result?.code || 'CLOCK_ADVANCE_UNVERIFIED');
+    status.textContent = 'SUCCESS';
+    details.textContent = result.status === 'SHORTENED_AFTER_REAL_20MIN'
+      ? 'Owned wall-clock acceptance threshold shortened after real 20 minutes; existing Worker will release only one verified Continue.'
+      : 'Observer still RUNNING; '+minutes+'m elapsed. Await the actual finished Turn.';
+    await chrome.tabs.remove(own.id);
+  } catch (error) {
+    status.textContent = 'BLOCKED';
+    details.textContent = error?.message || 'UNKNOWN';
+  }
+})();

package/extension/actions/common.js

@@ -0,0 +1,137 @@
+// Shared Eye Action primitives only. No action is dispatched or executed here.
+(() => {
+  const CONTRACT = "chat-loop.eye.v1";
+  const params = new URLSearchParams(location.search);
+  const statusNode = document.getElementById("status");
+  const detailsNode = document.getElementById("details");
+function show(status, message) {
+  statusNode.textContent = status;
+  detailsNode.textContent = message;
+}
+function fail(code, message) {
+  show(code, message);
+  document.body.dataset.result = "error";
+  console.error("Chat Loop eye:", code, message);
+}
+function isChatGPT(value) {
+  try {
+    const u = new URL(value);
+    return u.protocol === "https:" && u.hostname === "chatgpt.com";
+  } catch { return false; }
+}
+async function findTarget(ownTab) {
+  // Action pages may open in a different window from the ChatGPT tab.
+  const candidates = await chrome.tabs.query({url: "https://chatgpt.com/*"});
+  const eligible = candidates.filter(tab => isChatGPT(tab.url));
+  const requested = params.get("tabId");
+  if (requested !== null) {
+    if (!/^[1-9][0-9]*$/.test(requested)) throw Error("INVALID_TAB_ID");
+    const match = eligible.find(tab => tab.id === Number(requested));
+    if (!match) throw Error("TARGET_NOT_CHATGPT_OR_NOT_FOUND");
+    return match;
+  }
+  // When an action page was opened from a ChatGPT tab, respect its opener.
+  const opener = eligible.find(tab => tab.id === ownTab.openerTabId);
+  if (opener) return opener;
+  if (eligible.length === 0) throw Error("NO_CHATGPT_TAB");
+  if (eligible.length !== 1) {
+    const ids = eligible.map(tab => tab.id).join(", ");
+    throw Error("AMBIGUOUS_CHATGPT_TABS: use ?tabId=... (available: " + ids + ")");
+  }
+  return eligible[0];
+}
+async function closeAction(ownTab) {
+  await chrome.tabs.remove(ownTab.id);
+}
+async function readChat(tab, mode) {
+  const request = () => chrome.tabs.sendMessage(tab.id,
+    {type: "CHAT_LOOP_EYE_READ_V1", mode});
+  let response;
+  try {
+    response = await request();
+  } catch {
+    // Reload invalidates old content scripts. Reinject only into the selected ChatGPT tab.
+    try {
+      await chrome.scripting.executeScript({target: {tabId: tab.id}, files: ["content.js"]});
+      response = await request();
+    } catch {
+      throw Error("CONTENT_SCRIPT_UNAVAILABLE: could not reinject into ChatGPT tab");
+    }
+  }
+  if (response?.contract !== CONTRACT || response?.status !== "OK"
+    || response?.mode !== mode || typeof response?.value !== "string") {
+    throw Error("INVALID_CONTENT_RESPONSE");
+  }
+  return response.value;
+}
+function copyText(value) {
+  // Synchronous copy avoids losing the macOS pasteboard when this action tab closes.
+  const field = document.createElement("textarea");
+  field.value = value;
+  field.setAttribute("readonly", "");
+  field.style.position = "fixed";
+  field.style.opacity = "0";
+  document.body.appendChild(field);
+  field.focus();
+  field.select();
+  const copied = document.execCommand("copy");
+  field.remove();
+  if (!copied) throw Error("CLIPBOARD_COPY_FAILED");
+}
+  // Only requestId generated by the local CLI enables machine-result mode.
+  // Manual Action pages keep the verified clipboard/download behavior.
+  const nativeHost = "com.tomflow.chatloop.extension";
+  const machineId = params.get("requestId");
+  async function machineBinding(action) {
+    if (machineId === null) return null;
+    if (!/^[a-f0-9]{32}$/.test(machineId)) throw Error("INVALID_MACHINE_REQUEST");
+    const request = await chrome.runtime.sendNativeMessage(nativeHost,
+      {op:"acquire",id:machineId,action});
+    if (request?.status !== "OK" || request.id !== machineId || request.action !== action
+      || typeof request.nonce !== "string") throw Error(request?.code || "NATIVE_REQUEST_REJECTED");
+    const target = await chrome.runtime.sendMessage({
+      type:"CHAT_LOOP_EXTENSION_TARGET_V1",id:machineId,action
+    });
+    if (target?.status !== "OK") throw Error(target?.code || "OWNER_NOT_AVAILABLE");
+    return {id:machineId,nonce:request.nonce,action,
+      tabId:target.tabId??null,page:target.page??null};
+  }
+  async function machineTarget(binding) {
+    if (!binding || !Number.isInteger(binding.tabId)
+      || typeof binding.page !== "string") throw Error("OWNER_UNVERIFIED");
+    const tab = await chrome.tabs.get(binding.tabId);
+    if (!tab?.url || new URL(tab.url).pathname !== binding.page
+      || new URL(tab.url).origin !== "https://chatgpt.com") throw Error("OWNER_CHANGED");
+    return tab;
+  }
+  async function machineResult(binding,payload) {
+    const response = await chrome.runtime.sendNativeMessage(nativeHost,{
+      op:"complete",id:binding.id,nonce:binding.nonce,action:binding.action,status:"OK",payload
+    });
+    if(response?.status!=="SAVED"||response.id!==binding.id)throw Error(response?.code||"NATIVE_RESULT_UNVERIFIED");
+  }
+  async function machineFailure(action,error) {
+    if (machineId === null || !/^[a-f0-9]{32}$/.test(machineId)) return;
+    try {
+      const req=await chrome.runtime.sendNativeMessage(nativeHost,
+        {op:"acquire",id:machineId,action});
+      if(req?.status==="OK") await chrome.runtime.sendNativeMessage(nativeHost,{
+        op:"complete",id:machineId,nonce:req.nonce,action,status:"FAILED",
+        code:String(error?.message||"ACTION_FAILED").slice(0,120)
+      });
+    } catch { /* CLI timeout is UNKNOWN, never success. */ }
+  }
+  function requireOwnTab(tab) {
+    if (!tab?.id) throw Error("ACTION_TAB_UNVERIFIED");
+    return tab;
+  }
+  function done(ownTab, action, target) {
+    show("SUCCESS", action + " completed for tab " + target.id);
+    document.body.dataset.result = "success";
+    return closeAction(ownTab);
+  }
+  globalThis.ChatLoopActionCommonV1 = Object.freeze({
+    show, fail, findTarget, readChat, copyText, closeAction, done, requireOwnTab,
+    machineBinding, machineTarget, machineResult, machineFailure
+  });
+})();