@tomflow/chatloop-extension 0.0.0-stage → 0.3.28

package/extension/background.js

@@ -0,0 +1,946 @@
+// Chat Loop browser scheduler. It never types or clicks in ChatGPT.
+// Only extension-owned Action pages execute Continue or cross-Chat Handoff.
+importScripts("loop/core.js");
+const RUN_KEY = "chat-loop.action.run.v1";
+const HOUR_MS = 60 * 60 * 1000; // Acceptance wall-clock hours are independent of the MVP timeout.
+const RUN_BUDGET_MS = 10 * 60 * 1000; // Ten minutes per Chat; never interrupt a running Turn.
+const ALARM_NAME = "chat-loop.turn-watch.v1";
+// One-shot deadline on the same MV3 alarm facility; never sends a Chat message.
+const DEADLINE_ALARM_NAME = "chat-loop.handoff-deadline.v1";
+const COUNT_ALARM_NAME = "chat-loop.count-wait.v1";
+const COUNT_INTERVAL_MS = 60000;
+const CONTINUE_TEXT = "继续当前任务，完成本轮后只在末行写一个状态：[CHAT_LOOP_STATUS:CONTINUE]、[CHAT_LOOP_STATUS:DONE] 或 [CHAT_LOOP_STATUS:BLOCKED]。";
+// Explicit acceptance setup only, dispatched by the same formal Continue page.
+// Fixed harmless prompt; no arbitrary text or external write interface.
+const ACTION_TEST_TEXT = "这是 Chat Loop 短轮回归专用测试，不调用工具、不改文件。每次仅回复一句短话，最后一行单独输出一个协议状态标记。\n第1条消息：OK1，然后末行 [CHAT_LOOP_STATUS:CONTINUE]。\n第2条消息：OK2，然后末行 [CHAT_LOOP_STATUS:CONTINUE]。\n第3条消息：OK3，然后末行 [CHAT_LOOP_STATUS:DONE]。\n不主动交接，也不追加解释。校验串：LOOP-V037-FAST-3C1H。";
+const ACTION_TIMED_TEST_TEXT = "这是 Chat Loop 的长回复与一小时边界隔离测试，不能使用工具，不访问其他聊天，不改文件。请认真完成以下技术文字任务：用至少十八个独立自然段，以不同角度解释长任务的状态管理、异步任务完成检测、最终回执、一次性发送、跨会话交接、故障隔离与日志证据。段落各包含具体推理或例子，持续生成直到全部十八段完成。即使你看到与“时间到期”有关的叙述，也不要主动停止、跳过段落或交接。在全部正文结束后，最后一行只能输出 [CHAT_LOOP_STATUS:CONTINUE]；不能提前写出这个标记。当前 Chat 不再收到新的用户消息。\n\n如果你是在新 Chat 收到了包含【原始任务用户消息】【最近轮次证据】的定时交接，请忽略上述长文要求，只回复“定时交接接收完成”，并在最后一行输出 [CHAT_LOOP_STATUS:DONE]。\n\n本测试仅用于验证真正完成一个回复之后才触发交接，模型生成需要多久并没有固定值。校验串 LOOP-V037-FAST-3C1H / MODE-TIMED-1H。";
+const ACTION_WALL_TEST_TEXT = "这是 Chat Loop 的墙钟边界隔离测试，不调用工具、不改文件。原 Chat 每轮计算当前算式，第一行只写得数，末行单独写 [CHAT_LOOP_STATUS:CONTINUE]。第一题：1+1=？后续题目由 Continue 提供。新 Chat 若收到【原始任务用户消息】和【最近轮次证据】，只回复“已接班”，末行写 [CHAT_LOOP_STATUS:DONE]。交接仅由扩展按时钟决定。校验串 LOOP-V037-FAST-3C1H / MODE-WALL-10M / WALL-CLOCK-TEST。";
+// The arithmetic progression belongs ONLY to the controlled 10m acceptance
+// Chat. Each confirmed continuation asks a different, easily checked problem.
+// No prompt variation is a substitute for respecting website security checks.
+const wallArithmeticText = step => {
+  const left = Math.ceil(step / 2);
+  const right = step === 2 ? 3 : step;
+  return `第${step}题：${left}+${right}=？只写得数，末行写 [CHAT_LOOP_STATUS:CONTINUE]。`;
+};
+const COUNT_SETUP_TEXT = "这是 Chat Loop 的计数隔离验收，不调用工具、不改文件。初始整数86，本轮加1后输出87。以后每收到一条Continue才加1。每轮只能输出两行：第一行是整数；第二行是状态，整数小于100输出 [CHAT_LOOP_STATUS:CONTINUE]，等于100才输出 [CHAT_LOOP_STATUS:DONE]。新Chat从交接包的最后已确认数值继续加1，交接本身不得DONE。十分钟交接由扩展执行，60秒发送间隔由扩展控制。校验串 LOOP-V037-FAST-3C1H / MODE-WALL-10M / COUNT-86-100 / WALL-CLOCK-TEST。";
+const countText = n => `上一轮确认数字是${n}。本轮只加1，第一行只输出${n + 1}；第二行数字未到100写 [CHAT_LOOP_STATUS:CONTINUE]，达到100才写 [CHAT_LOOP_STATUS:DONE]。`;
+const readCount = reply => {
+  const m = String(reply).trim().match(/(?:^|\n)\s*(\d{2,3})\s*\r?\n\s*\[CHAT_LOOP_STATUS:(?:CONTINUE|DONE)\]$/);
+  return m ? Number(m[1]) : null;
+};
+let queue = Promise.resolve();
+const serial = fn => {
+  const work = queue.then(fn);
+  queue = work.catch(() => {});
+  return work;
+};
+const pathOf = url => {
+  try {
+    const u = new URL(url);
+    const path = u.pathname.replace(/\/$/, "");
+    return u.origin === "https://chatgpt.com"
+      && /^\/(?:c\/[0-9a-f-]{12,}|g\/[^/]+\/c\/[0-9a-f-]{12,})$/i.test(path)
+      ? path : "";
+  } catch { return ""; }
+};
+const readRun = async () => (await chrome.storage.local.get(RUN_KEY))[RUN_KEY] || null;
+const windowMsOf = run => Number.isSafeInteger(run?.windowMs) && run.windowMs > 0
+  ? run.windowMs : run?.timedTest && run.wallTestMinutes === 20
+    ? 20 * 60 * 1000 : RUN_BUDGET_MS;
+const deadlineOf = run => Number.isSafeInteger(run?.startedAt) && run.startedAt > 0
+  ? run.startedAt + windowMsOf(run) : null;
+const clockActive = run => run && ["RESERVED", "PENDING", "WAITING_REPLY", "WAITING_INTERVAL"].includes(run.phase)
+  && !run.testSetup && !run.wallTestHours;
+async function saveRun(run) {
+  const now = Date.now(), deadlineAt = deadlineOf(run);
+  // Persist the intent even when a delayed alarm arrives after an Action
+  // receipt. This never revokes a Continue already reserved before deadline.
+  const next = {...run, ...(deadlineAt ? {deadlineAt} : {})};
+  if (clockActive(next) && deadlineAt !== null && now >= deadlineAt
+    && !next.handoffPending) {
+    next.handoffPending = true;
+    next.handoffPendingAt = now;
+  }
+  await chrome.storage.local.set({[RUN_KEY]: next});
+  try {
+    if (clockActive(next) && !next.handoffPending && deadlineAt > Date.now()) {
+      await chrome.alarms?.create?.(DEADLINE_ALARM_NAME, {when: deadlineAt});
+    } else {
+      await chrome.alarms?.clear?.(DEADLINE_ALARM_NAME);
+    }
+    if (next.phase === "WAITING_INTERVAL" && next.countMode && !next.handoffPending)
+      await chrome.alarms?.create?.(COUNT_ALARM_NAME, {when: next.countReleaseAt});
+    else await chrome.alarms?.clear?.(COUNT_ALARM_NAME);
+  } catch { /* The existing periodic alarm is a conservative backup. */ }
+}
+async function prepareHandoffIfDue() {
+  const run = await readRun();
+  const deadlineAt = deadlineOf(run);
+  if (!clockActive(run) || run.handoffPending || deadlineAt === null
+    || Date.now() < deadlineAt) return;
+  await saveRun({...run, handoffPending: true,
+    handoffPendingAt: Date.now()});
+}
+// Chrome preserves a content script's original document sender.url across SPA
+// / → /c/... navigation. Authenticate its origin, then read the CURRENT tab URL.
+const eligible = async (sender, page) => {
+  if (!Number.isInteger(sender.tab?.id) || typeof page !== "string"
+    || pathOf("https://chatgpt.com" + page) !== page) return false;
+  try {
+    if (new URL(sender.url).origin !== "https://chatgpt.com") return false;
+    const tab = await chrome.tabs.get(sender.tab.id);
+    return pathOf(tab.url) === page;
+  } catch { return false; }
+};
+
+// A transient partial UI snapshot may end with UNKNOWN even when the same
+// already-confirmed reply later settles on a valid final status. Only resample
+// the exact in-flight user/assistant turn, read-only, before failing closed.
+async function recheckUnknownTurn(message, previous, tabId) {
+  if (previous?.phase !== "WAITING_REPLY" || previous.tabId !== tabId
+    || previous.page !== message.page || previous.newUserKey !== message.userKey
+    || previous.assistantKey === message.assistantKey) return null;
+  const read = async () => {
+    const tab = await chrome.tabs.get(tabId).catch(() => null);
+    if (pathOf(tab?.url) !== message.page) return null;
+    const proof = await chrome.tabs.sendMessage(tabId,
+      {type: "CHAT_LOOP_TURN_VERIFY_V1"}).catch(() => null);
+    if (proof?.contract !== "chat-loop.turn-observer.v1" || proof.status !== "READY"
+      || proof.page !== message.page || proof.userKey !== message.userKey
+      || proof.assistantKey !== message.assistantKey
+      || typeof proof.replyText !== "string") return null;
+    return proof.replyText;
+  };
+  for (let attempt = 0; attempt < 8; attempt++) {
+    const first = await read();
+    if (first === null) return null;
+    const parsed = globalThis.ChatLoopCoreV1.parseStatus(first);
+    if (parsed !== "UNKNOWN") {
+      await new Promise(resolve => setTimeout(resolve, 2300));
+      const second = await read();
+      if (second === first) return {status: parsed, replyText: second};
+    } else {
+      await new Promise(resolve => setTimeout(resolve, 1500));
+    }
+  }
+  return null;
+}
+async function onTurnBlocked(message, sender) {
+  const reason = message.reason;
+  if (!["PAGE_ERROR", "CONTEXT_LIMIT", "SECURITY_CHALLENGE"].includes(reason)
+    || !await eligible(sender, message.page)
+    || typeof message.userKey !== "string" || !/^user:[^\s]{8,}$/.test(message.userKey))
+    return {status: "DENIED", code: "ERROR_SOURCE_UNVERIFIED"};
+  const previous = await readRun();
+  if (previous?.phase !== "WAITING_REPLY" || previous.tabId !== sender.tab.id
+    || previous.page !== message.page || previous.newUserKey !== message.userKey)
+    return {status: "IGNORED", code: "NOT_OWNED_RUNNING_TURN"};
+  const verify = async () => {
+    const proof = await chrome.tabs.sendMessage(previous.tabId,
+      {type: "CHAT_LOOP_TURN_OBSERVE_V1", poll: true}).catch(() => null);
+    return proof?.contract === "chat-loop.turn-observer.v1"
+      && proof.status === "BLOCKED" && proof.reason === reason
+      && proof.page === previous.page && proof.userKey === previous.newUserKey
+      ? proof : null;
+  };
+  const first = await verify();
+  if (!first) return {status: "IGNORED", code: "ERROR_NOT_CONFIRMED"};
+  await new Promise(resolve => setTimeout(resolve, 400));
+  const second = await verify();
+  if (!second || first.retryAvailable !== second.retryAvailable)
+    return {status: "IGNORED", code: "ERROR_NOT_STABLE"};
+  // A security challenge is an explicit stop condition, not a prompt to retry
+  // or evade site access controls. Keep the original Chat and user Turn intact.
+  if (reason === "SECURITY_CHALLENGE") {
+    await saveRun({...previous, phase:"BLOCKED", reason,
+      errorUserKey:message.userKey, errorAt:Date.now()});
+    return {status:"BLOCKED", code:reason};
+  }
+  // The second capacity failure immediately after an ERROR Handoff must not
+  // start an infinite series of new ChatGPT conversations.
+  const errorHandoffCount = previous.errorHandoffCount || 0;
+  if (reason === "CONTEXT_LIMIT" && errorHandoffCount < 1
+    || reason === "PAGE_ERROR" && previous.retryCount !== 1 && second.retryAvailable === true) {
+    const retry = reason === "PAGE_ERROR";
+    const token = crypto.randomUUID();
+    const next = {...previous, phase: "RESERVED", action: retry ? "CONTINUE" : "HANDOFF",
+      token, reason: "", ...(retry ? {retryMode: "NATIVE", retryCount: 1}
+        : {handoffMode: "ERROR", errorReason: reason})};
+    await saveRun(next); // Durable before opening the only authorized Action.
+    try {
+      const url = chrome.runtime.getURL(retry ? "continue.html" : "handoff.html")
+        + "?tabId=" + previous.tabId + "&token=" + encodeURIComponent(token);
+      const actionTab = await chrome.tabs.create({url, active: false, windowId: sender.tab.windowId});
+      return {status: "QUEUED", actionTabId: actionTab.id, code: retry ? "NATIVE_RETRY_ONCE" : "CONTEXT_HANDOFF"};
+    } catch {
+      await saveRun({...next, phase: "BLOCKED", reason: "ERROR_ACTION_CREATE_FAILED"});
+      return {status: "BLOCKED", code: "ERROR_ACTION_CREATE_FAILED"};
+    }
+  }
+  await saveRun({...previous, phase: "BLOCKED", reason: reason === "PAGE_ERROR"
+    ? previous.retryCount === 1 ? "PAGE_ERROR_AFTER_RETRY" : "PAGE_ERROR_NO_RETRY_BUTTON"
+    : "CONTEXT_HANDOFF_REPEATED", errorUserKey: message.userKey, errorAt: Date.now()});
+  return {status: "BLOCKED", code: reason === "PAGE_ERROR" ? "PAGE_ERROR" : "CONTEXT_HANDOFF_REPEATED"};
+}
+async function onTurnFinished(message, sender) {
+  if (!await eligible(sender, message.page)
+    || typeof message.userKey !== "string" || !/^user:[^\s]{8,}$/.test(message.userKey)
+    || typeof message.assistantKey !== "string"
+    || !/^assistant:[^\s]{8,}$/.test(message.assistantKey)
+    || typeof message.replyText !== "string" || message.replyText.length > 100000) {
+    return {status: "DENIED", code: "UNVERIFIED_TURN_SOURCE"};
+  }
+  const tabId = sender.tab.id;
+  const previous = await readRun();
+  // A Chat is owned only after an extension Action has explicitly reserved
+  // and confirmed its user Turn. A status marker on an arbitrary Chat never
+  // starts or reactivates a loop, including after DONE/BLOCKED.
+  if (previous?.testSetup && previous.tabId === tabId)
+    return {status: "IGNORED", code: "TEST_SETUP_UNVERIFIED"};
+  if (!previous || ["DONE", "BLOCKED"].includes(previous.phase))
+    return {status: "IGNORED", code: "NO_ACTIVE_OWNER"};
+  if (previous.tabId !== tabId || previous.page !== message.page)
+    return {status: "IGNORED", code: "ANOTHER_CHAT_OWNS_LOOP"};
+  if (["PENDING", "RESERVED"].includes(previous.phase))
+    return {status: "IGNORED", code: previous.phase};
+  if (previous.assistantKey === message.assistantKey
+    || previous.userKey === message.userKey)
+    return {status: "IGNORED", code: "ALREADY_HANDLED"};
+  if (previous.phase !== "WAITING_REPLY")
+    return {status: "IGNORED", code: "INVALID_PHASE"};
+  if (message.userKey !== previous.newUserKey) {
+    await saveRun({...previous, phase: "BLOCKED", reason: "REPLY_USER_MISMATCH"});
+    return {status: "BLOCKED", code: "REPLY_USER_MISMATCH"};
+  }
+  let replyText = message.replyText;
+  let status = globalThis.ChatLoopCoreV1.parseStatus(replyText);
+  if (status === "UNKNOWN") {
+    const recovery = await recheckUnknownTurn(message, previous, tabId);
+    if (recovery) {status = recovery.status; replyText = recovery.replyText;}
+  }
+  // Dedicated acceptance Chats only: retain the exact unrecognized reply to
+  // diagnose real UI text wrappers. Never persist private user Chat text.
+  let parseEvidence = null;
+  if (status === "UNKNOWN") {
+    const owned = (await chrome.storage.local.get("chat-loop.acceptance.owned.v1"))[
+      "chat-loop.acceptance.owned.v1"];
+    if (Array.isArray(owned) && owned.some(item => item.id === tabId || item.id === previous?.sourceTabId)) {
+      parseEvidence = {replyText: message.replyText.slice(0, 2500),
+        length: message.replyText.length, capturedAt: Date.now()};
+    }
+  }
+  const countMode = previous?.countMode === true;
+  let verifiedCount = null;
+  if (countMode && (status === "CONTINUE" || status === "DONE")) {
+    verifiedCount = readCount(replyText);
+    if (verifiedCount !== previous.countValue + 1
+      || status !== (verifiedCount === 100 ? "DONE" : "CONTINUE")) {
+      await saveRun({...previous, phase: "BLOCKED", reason: "COUNT_STEP_UNVERIFIED"});
+      return {status: "BLOCKED", code: "COUNT_STEP_UNVERIFIED"};
+    }
+  }
+  const now = Date.now();
+  // Keep the same clock throughout one Chat. A successful Handoff resets it.
+  const initial = Number.isSafeInteger(message.startedAt) && message.startedAt > 0
+    && message.startedAt <= now ? message.startedAt : now;
+  const startedAt = previous?.phase === "WAITING_REPLY" ? previous.startedAt || now : initial;
+  const timeExpired = now >= startedAt + windowMsOf(previous);
+  // Deadline intent can be persisted by the timer even while a Turn RUNS.
+  // The decision below still waits for the observer's complete Turn proof.
+  let nextAction = status === "HANDOFF" ? "UNSUPPORTED_MODEL_HANDOFF"
+    : (previous?.handoffPending || timeExpired) && status === "CONTINUE"
+      ? "HANDOFF" : status;
+  if (nextAction !== "CONTINUE" && nextAction !== "HANDOFF") {
+    if (previous?.phase === "WAITING_REPLY" && previous.tabId === tabId) {
+      await saveRun({...previous, phase: status === "DONE" ? "DONE" : "BLOCKED",
+        reason: status, userKey: message.userKey, assistantKey: message.assistantKey,
+        ...(countMode && verifiedCount !== null ? {countValue: verifiedCount} : {}),
+        ...(parseEvidence ? {parseEvidence} : {})});
+    }
+    return {status: "IGNORED", code: nextAction === "UNSUPPORTED_MODEL_HANDOFF"
+      ? "MODEL_HANDOFF_DISABLED" : status};
+  }
+  // Historical 1h/2h endurance fixtures explicitly park the Chat to avoid
+  // huge message counts; the real 10m acceptance MUST use the normal running
+  // loop: each finished CONTINUE immediately dispatches Continue, without a hold.
+  if (previous?.wallTestHours
+    && status === "CONTINUE" && !timeExpired
+    && !previous.wallReleasedAt && previous.phase === "WAITING_REPLY") {
+    const releaseAt = startedAt + (previous.wallTestMinutes === 10
+      ? RUN_BUDGET_MS : previous.wallTestHours * HOUR_MS);
+    await saveRun({...previous, phase: "WALL_CLOCK_HOLD", reason: "ACCEPTANCE_WALL_WAIT",
+      userKey: message.userKey, assistantKey: message.assistantKey,
+      wallHoldAt: now, wallReleaseAt: releaseAt});
+    return {status: "WAITING_DEADLINE", releaseAt};
+  }
+  // Count acceptance: completion is recorded now, but the next Continue is
+  // not authorized until 60 real seconds after the previous confirmed send.
+  if (countMode && nextAction === "CONTINUE" && !timeExpired
+    && now < previous.countLastSendAt + COUNT_INTERVAL_MS) {
+    const countReleaseAt = previous.countLastSendAt + COUNT_INTERVAL_MS;
+    await saveRun({...previous, phase: "WAITING_INTERVAL", reason: "COUNT_INTERVAL",
+      userKey: message.userKey, assistantKey: message.assistantKey,
+      countValue: verifiedCount, countReleaseAt});
+    return {status: "WAITING_INTERVAL", countReleaseAt};
+  }
+  // Recheck at the last new-authorization boundary, even if a periodic or
+  // one-shot alarm was delayed while the Worker handled completion evidence.
+  const newlyDue = Date.now() >= startedAt + windowMsOf(previous);
+  if (nextAction === "CONTINUE" && newlyDue) nextAction = "HANDOFF";
+  const token = crypto.randomUUID();
+  const run = {tabId, page: message.page, userKey: message.userKey,
+    assistantKey: message.assistantKey, phase: "RESERVED", token,
+    action: nextAction, startedAt,
+    ...(countMode ? {countMode:true, countValue:verifiedCount,
+      countLastSendAt:previous.countLastSendAt,
+      countHandoffs:previous.countHandoffs || 0} : {}),
+    ...((previous?.handoffPending || newlyDue) ? {
+      handoffPending: true,
+      handoffPendingAt: previous?.handoffPendingAt || Date.now()} : {}),
+    // A completed Turn is a successful recovery and clears the consecutive error-Handoff guard.
+    errorHandoffCount: 0,
+    // Carry only dedicated acceptance evidence across the finished Turn. The
+    // evidence proves the deadline was crossed while Observer was RUNNING.
+    ...(previous?.timedTest && previous?.clockAdvancedAt ? {
+      timedTest: true, clockAdvancedAt: previous.clockAdvancedAt,
+      clockAdvanceMinutes: previous.clockAdvanceMinutes,
+      clockRunningProof: previous.clockRunningProof} : {}),
+    // Keep the 10m continuous-flow test identity only for audit evidence;
+    // unlike historical hour-long endurance it never delays the next Continue.
+    ...(previous?.timedTest && previous?.wallTestMinutes === 10 ? {
+      timedTest: true, wallTestMinutes: 10,
+      testTurnIndex: (previous.testTurnIndex || 1) + 1} : {}),
+    // Preserve historical wall-clock hold receipt across its subsequent Turn.
+    ...(previous?.timedTest && previous?.wallReleasedAt ? {
+      timedTest: true, wallTestHours: previous.wallTestHours,
+      wallHoldAt: previous.wallHoldAt, wallReleaseAt: previous.wallReleaseAt,
+      wallReleasedAt: previous.wallReleasedAt,
+      ...([10, 20].includes(previous.wallTestMinutes) ? {
+        wallTestMinutes: previous.wallTestMinutes,
+        ...(previous.wallTestMinutes === 20 ? {wallAdjustedAt: previous.wallAdjustedAt,
+          wallOriginalReleaseAt: previous.wallOriginalReleaseAt} : {})} : {})} : {}),
+    // A timed Handoff uses an Action-local read-only snapshot. Do not keep
+    // the entire conversation in storage or embed it in the Action URL.
+    handoffMode: nextAction === "HANDOFF" ? "TIMED" : null};
+  // Durable before opening an Action; an uncertain outcome must never be retried.
+  await saveRun(run);
+  try {
+    const url = chrome.runtime.getURL(nextAction === "HANDOFF" ? "handoff.html" : "continue.html")
+      + "?tabId=" + tabId + "&token=" + encodeURIComponent(token);
+    const actionTab = await chrome.tabs.create({url, active: false, windowId: sender.tab.windowId});
+    return {status: "QUEUED", actionTabId: actionTab.id};
+  } catch (error) {
+    await saveRun({...run, phase: "BLOCKED", reason: "ACTION_PAGE_CREATE_FAILED"});
+    return {status: "BLOCKED", code: error.message || "ACTION_PAGE_CREATE_FAILED"};
+  }
+}
+// Release a verified completed count Turn only after the persisted 60s gate.
+// The independent 10m cutoff wins over an unissued Continue.
+async function releaseCountInterval() {
+  const old = await readRun();
+  if (old?.phase !== "WAITING_INTERVAL" || old.countMode !== true) return;
+  const now = Date.now(), deadline = deadlineOf(old);
+  if (now < old.countReleaseAt && now < deadline && !old.handoffPending) return;
+  const tab = await chrome.tabs.get(old.tabId).catch(() => null);
+  if (pathOf(tab?.url) !== old.page) {
+    await saveRun({...old, phase:"BLOCKED", reason:"COUNT_TAB_CHANGED"});
+    return;
+  }
+  const proof = await chrome.tabs.sendMessage(old.tabId,
+    {type:"CHAT_LOOP_TURN_VERIFY_V1"}).catch(() => null);
+  if (proof?.status !== "READY" || proof.page !== old.page
+    || proof.userKey !== old.userKey || proof.assistantKey !== old.assistantKey
+    || readCount(proof.replyText) !== old.countValue) {
+    await saveRun({...old, phase:"BLOCKED", reason:"COUNT_TURN_CHANGED"});
+    return;
+  }
+  const action = old.handoffPending || Date.now() >= deadline ? "HANDOFF" : "CONTINUE";
+  const run = {...old, phase:"RESERVED", action, token:crypto.randomUUID(),
+    handoffMode: action === "HANDOFF" ? "TIMED" : null};
+  delete run.countReleaseAt;
+  await saveRun(run);
+  try {
+    await chrome.tabs.create({url:chrome.runtime.getURL(action === "HANDOFF"
+      ? "handoff.html" : "continue.html") + "?tabId=" + old.tabId
+      + "&token=" + encodeURIComponent(run.token), active:false, windowId:tab.windowId});
+  } catch {
+    await saveRun({...run,phase:"BLOCKED",reason:"COUNT_ACTION_OPEN_FAILED"});
+  }
+}
+// Opening a formal Action page manually is a supported test/debug entry.
+// No token in URL: the Worker verifies a single explicit target and reserves
+// this exact Action tab. It never sends or creates the new Chat itself.
+async function onManualPrepare(message, sender) {
+  const requested = message.action;
+  if (!["CONTINUE", "HANDOFF"].includes(requested)
+    || !Number.isInteger(sender.tab?.id)) return {status: "DENIED", code: "INVALID_MANUAL_ACTION"};
+  const filename = requested === "HANDOFF" ? "handoff.html" : "continue.html";
+  let url;
+  try { url = new URL(sender.url); } catch {return {status: "DENIED", code: "INVALID_ACTION_URL"};}
+  const rawTabId = url.searchParams.get("tabId");
+  if (url.origin !== new URL(chrome.runtime.getURL(filename)).origin
+    || url.pathname !== "/" + filename || url.searchParams.has("token")
+    || Array.from(url.searchParams.keys()).some(key => key !== "tabId")
+    || (rawTabId !== null && (!/^[1-9][0-9]*$/.test(rawTabId)
+      || message.tabId !== Number(rawTabId))))
+    return {status: "DENIED", code: "INVALID_ACTION_URL"};
+  const previous = await readRun();
+  if (previous && !["DONE", "BLOCKED"].includes(previous.phase))
+    return {status: "DENIED", code: "LOOP_ALREADY_ACTIVE"};
+  const candidates = await chrome.tabs.query({url: "https://chatgpt.com/*"});
+  const all = candidates.filter(tab => Number.isInteger(tab.id) && pathOf(tab.url));
+  let tab;
+  if (Number.isInteger(message.tabId)) tab = all.find(item => item.id === message.tabId);
+  else if (all.length === 1) tab = all[0];
+  else return {status: "DENIED", code: all.length ? "AMBIGUOUS_CHATGPT_TABS" : "NO_CHATGPT_TAB"};
+  if (!tab) return {status: "DENIED", code: "TARGET_CHAT_NOT_FOUND"};
+  const query = () => chrome.tabs.sendMessage(tab.id, {type: "CHAT_LOOP_TURN_VERIFY_V1"});
+  let first;
+  try {first = await query();}
+  catch {return {status: "DENIED", code: "OBSERVER_NOT_READY"};}
+  if (first?.contract !== "chat-loop.turn-observer.v1" || first.status !== "READY"
+    || first.page !== pathOf(tab.url)) return {status: "DENIED", code: "TURN_NOT_FINISHED"};
+  // A manually opened page is still forbidden from interrupting late updates.
+  await new Promise(resolve => setTimeout(resolve, 2300));
+  const second = await query().catch(() => null);
+  if (second?.status !== "READY" || second.page !== first.page
+    || second.userKey !== first.userKey || second.assistantKey !== first.assistantKey
+    || second.replyText !== first.replyText) return {status: "DENIED", code: "TURN_NOT_STABLE"};
+  const modelStatus = globalThis.ChatLoopCoreV1.parseStatus(first.replyText);
+  if (requested === "CONTINUE" && modelStatus !== "CONTINUE"
+    || requested === "HANDOFF" && !["HANDOFF", "CONTINUE"].includes(modelStatus))
+    return {status: "DENIED", code: "ACTION_MARKER_MISMATCH"};
+  if (previous && previous.tabId === tab.id && previous.page === first.page
+    && (previous.userKey === first.userKey || previous.assistantKey === first.assistantKey))
+    return {status: "DENIED", code: "ALREADY_HANDLED"};
+  const summary = modelStatus === "HANDOFF"
+    ? first.replyText.replace(/\r?\n\[CHAT_LOOP_STATUS:HANDOFF\]\s*$/, "").trim() : null;
+  if (summary && (summary.length < 120 || summary.length > 16000
+    || !/目标/.test(summary) || !/已完成|进度/.test(summary)
+    || !/下一步|待办/.test(summary)))
+    return {status: "DENIED", code: "HANDOFF_PACKET_MISSING"};
+  const token = crypto.randomUUID();
+  await saveRun({tabId: tab.id, page: first.page, userKey: first.userKey,
+    assistantKey: first.assistantKey, phase: "RESERVED", token,
+    action: requested, startedAt: Date.now(), manualActionTabId: sender.tab.id,
+    handoffMode: requested === "HANDOFF"
+      ? (modelStatus === "HANDOFF" ? "EXPLICIT" : "TIMED") : null,
+    ...(summary ? {handoffText: summary} : {})});
+  return {status: "PREPARED", token, tabId: tab.id};
+}
+// This is a test preparation permit, not a successful Continue regression.
+// Both readiness probes are read-only; PENDING must be durable before any edit.
+async function onTestPrepare(message, sender) {
+  const tabId = message.tabId;
+  if (!Number.isInteger(tabId) || !Number.isInteger(sender.tab?.id)
+    || ![chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&discardDraft=1",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&timed=1",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&discardDraft=1&timed=1",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&timed=1&wall=1",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&discardDraft=1&timed=1&wall=1",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&timed=1&wall=2",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&discardDraft=1&timed=1&wall=2",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&timed=1&wall=10m",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&discardDraft=1&timed=1&wall=10m",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&timed=1&wall=10m&count=86",
+      chrome.runtime.getURL("continue.html") + "?tabId=" + tabId + "&setup=1&discardDraft=1&timed=1&wall=10m&count=86"].includes(sender.url))
+    return {status: "DENIED", code: "INVALID_TEST_ACTION"};
+  const previous = await readRun();
+  if (previous && !["DONE", "BLOCKED"].includes(previous.phase))
+    return {status: "DENIED", code: "LOOP_ALREADY_ACTIVE"};
+  if (previous?.tabId === tabId)
+    return {status: "DENIED", code: "TEST_TARGET_ALREADY_USED"};
+  const tab = await chrome.tabs.get(tabId).catch(() => null);
+  if (tab?.url !== "https://chatgpt.com/")
+    return {status: "DENIED", code: "TEST_TARGET_NOT_BLANK"};
+  const params = new URL(sender.url).searchParams;
+  const discardDraft = params.get("discardDraft") === "1";
+  const timedTest = params.get("timed") === "1";
+  const wall = params.get("wall");
+  const wallTestHours = wall && wall !== "10m" ? Number(wall) : null;
+  const wallTestMinutes = wall === "10m" ? 10 : null;
+  const countMode = params.get("count") === "86";
+  if (params.has("count") && (!countMode || !timedTest || wallTestMinutes !== 10))
+    return {status:"DENIED",code:"COUNT_TEST_INVALID"};
+  if (wall !== null && (!timedTest || !(wallTestMinutes === 10 || [1, 2].includes(wallTestHours))))
+    return {status: "DENIED", code: "INVALID_WALL_TEST"};
+  if (timedTest) {
+    const registry = (await chrome.storage.local.get("chat-loop.acceptance.owned.v1"))[
+      "chat-loop.acceptance.owned.v1"];
+    if (!Array.isArray(registry) || !registry.some(item => item.id === tabId))
+      return {status: "DENIED", code: "TIMED_TEST_OWNERSHIP_REQUIRED"};
+  }
+  const probe = async () => {
+    const [read] = await chrome.scripting.executeScript({target: {tabId}, func: allowDiscard => {
+      const visible = node => Boolean(node?.getClientRects?.().length);
+      const mains = [...document.querySelectorAll("main")].filter(visible);
+      const input = document.querySelector('[contenteditable="true"][data-composer-markdown]')
+        || document.querySelector('#prompt-textarea[contenteditable="true"]');
+      const draft = (input?.innerText || input?.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 <= 800)
+        || (draft.startsWith("你正在接手上一 Chat 尚未完成的同一个任务")
+          && draft.length <= 8192 && (draft.length <= 2000
+            || (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("COUNT-86-100") && draft.endsWith("WALL-CLOCK-TEST。"))
+        || ((draft.startsWith("这是 Chat Loop 的长回复与一小时边界隔离测试")
+          || draft.startsWith("这是 Chat Loop 的墙钟边界隔离测试"))
+          && (draft.includes("MODE-TIMED-1H") || draft.includes("MODE-WALL-10M"))));
+      return location.href === "https://chatgpt.com/" && mains.length === 1
+        && !mains[0].querySelector('[data-chatgpt-search-message-ids],[data-message-author-role]')
+        && visible(input) && (!draft || (allowDiscard && knownTestDraft))
+        && ![...document.querySelectorAll('button[data-testid="stop-button"]')].some(visible);
+    }, args: [discardDraft]});
+    return read?.result === true;
+  };
+  if (!await probe()) return {status: "DENIED", code: "TEST_TARGET_NOT_EMPTY"};
+  await new Promise(resolve => setTimeout(resolve, 2300));
+  if (!await probe()) return {status: "DENIED", code: "TEST_TARGET_NOT_STABLE"};
+  const token = crypto.randomUUID();
+  await saveRun({tabId, page: "/", userKey: null, assistantKey: null,
+    phase: "RESERVED", token, action: "CONTINUE", testSetup: true, discardDraft,
+    ...(timedTest ? {timedTest: true} : {}),
+    ...(wallTestHours ? {wallTestHours} : {}),
+    ...(wallTestMinutes ? {wallTestMinutes} : {}),
+    ...(countMode ? {countMode:true, countValue:86, countHandoffs:0} : {}),
+    // The first Turn starts with a real clock, including acceptance tests.
+    // A dedicated test Action may advance it later only while Observer RUNNING.
+    startedAt: Date.now(),
+    manualActionTabId: sender.tab.id});
+  return {status: "PREPARED", token, tabId};
+}
+async function onAcceptanceShortenWallHold(message, sender) {
+  // User-requested shortening of an existing *owned acceptance* wait.
+  // The real elapsed time must already exceed 20 min; never backdate time.
+  const tabId = message.tabId, now = Date.now();
+  if (!Number.isSafeInteger(tabId) || tabId <= 0
+    || message.minutes !== 20 || !Number.isSafeInteger(sender.tab?.id)
+    || sender.url !== chrome.runtime.getURL("clock.html")
+      + "?tabId=" + tabId + "&minutes=20")
+    return {status: "DENIED", code: "SHORTEN_SOURCE_INVALID"};
+  const run = await readRun();
+  if (run?.phase !== "WALL_CLOCK_HOLD" || run.tabId !== tabId
+    || run.timedTest !== true || run.wallTestHours !== 2
+    || run.wallAdjustedAt || !run.userKey || !run.assistantKey
+    || !Number.isSafeInteger(run.startedAt)
+    || now < run.startedAt + 20 * 60 * 1000)
+    return {status: "DENIED", code: "SHORTEN_NOT_ELIGIBLE"};
+  const owned = (await chrome.storage.local.get("chat-loop.acceptance.owned.v1"))[
+    "chat-loop.acceptance.owned.v1"];
+  if (!Array.isArray(owned) || !owned.some(item => item.id === tabId))
+    return {status: "DENIED", code: "SHORTEN_NOT_OWNED"};
+  const tab = await chrome.tabs.get(tabId).catch(() => null);
+  if (!tab || pathOf(tab.url) !== run.page)
+    return {status: "DENIED", code: "SHORTEN_TARGET_CHANGED"};
+  const verify = async () => {
+    const proof = await chrome.tabs.sendMessage(tabId,
+      {type: "CHAT_LOOP_TURN_VERIFY_V1"}).catch(() => null);
+    return proof?.contract === "chat-loop.turn-observer.v1"
+      && proof.status === "READY" && proof.page === run.page
+      && proof.userKey === run.userKey
+      && proof.assistantKey === run.assistantKey
+      && globalThis.ChatLoopCoreV1.parseStatus(proof.replyText) === "CONTINUE";
+  };
+  if (!await verify()) return {status: "DENIED", code: "SHORTEN_NOT_STABLE"};
+  await new Promise(resolve => setTimeout(resolve, 2300));
+  if (!await verify()) return {status: "DENIED", code: "SHORTEN_IDENTITY_CHANGED"};
+  const latest = await readRun();
+  if (latest?.phase !== "WALL_CLOCK_HOLD" || latest.tabId !== run.tabId
+    || latest.wallHoldAt !== run.wallHoldAt || latest.userKey !== run.userKey)
+    return {status: "DENIED", code: "SHORTEN_OWNER_CHANGED"};
+  const changed = {...latest,
+    wallOriginalReleaseAt: latest.wallReleaseAt,
+    wallReleaseAt: latest.startedAt + 20 * 60 * 1000,
+    wallTestMinutes: 20, wallAdjustedAt: Date.now()};
+  await saveRun(changed);
+  return {status: "SHORTENED_AFTER_REAL_20MIN", tabId,
+    startedAt: changed.startedAt, releaseAt: changed.wallReleaseAt,
+    adjustedAt: changed.wallAdjustedAt};
+}
+async function onAcceptanceClockAdvance(message, sender) {
+  if (message?.minutes === 20) return onAcceptanceShortenWallHold(message, sender);
+  // Test-only clock mutation. All production time comparisons remain unchanged.
+  // This must happen DURING the assistant Turn, never before the first Turn.
+  const tabId = message.tabId, minutes = message.minutes;
+  if (!Number.isSafeInteger(tabId) || tabId <= 0
+    || !Number.isSafeInteger(minutes) || minutes < 60 || minutes > 180
+    || sender.url !== chrome.runtime.getURL("clock.html")
+      + "?tabId=" + tabId + "&minutes=" + minutes
+    || !Number.isSafeInteger(sender.tab?.id))
+    return {status: "DENIED", code: "CLOCK_ACTION_SOURCE_INVALID"};
+  const run = await readRun();
+  if (run?.phase !== "WAITING_REPLY" || run?.action !== "CONTINUE"
+    || run?.tabId !== tabId || run?.timedTest !== true
+    || run?.clockAdvancedAt || !run.newUserKey || !run.page
+    || run.testSetup) return {status: "DENIED", code: "CLOCK_TEST_NOT_WAITING"};
+  const owned = (await chrome.storage.local.get("chat-loop.acceptance.owned.v1"))[
+    "chat-loop.acceptance.owned.v1"];
+  if (!Array.isArray(owned) || !owned.some(item => item.id === tabId))
+    return {status: "DENIED", code: "CLOCK_TEST_NOT_OWNED"};
+  const live = await chrome.tabs.get(tabId).catch(() => null);
+  if (!live || pathOf(live.url) !== run.page)
+    return {status: "DENIED", code: "CLOCK_TARGET_CHANGED"};
+  const sample = async () => chrome.tabs.sendMessage(tabId,
+    {type: "CHAT_LOOP_TURN_OBSERVE_V1", poll: true}).catch(() => null);
+  const isRunning = x => x?.contract === "chat-loop.turn-observer.v1"
+    && x.status === "RUNNING" && x.page === run.page
+    && x.userKey === run.newUserKey;
+  const first = await sample();
+  if (!isRunning(first)) return {status: "DENIED", code: "CLOCK_TURN_NOT_RUNNING"};
+  await new Promise(resolve => setTimeout(resolve, 300));
+  const second = await sample();
+  if (!isRunning(second)) return {status: "DENIED", code: "CLOCK_TURN_NOT_STABLE_RUNNING"};
+  const now = Date.now();
+  // Advance by a test-chosen elapsed duration, not by a hard-coded 61 minutes.
+  // No scheduler event or writing action is dispatched at this moment.
+  await saveRun({...run, startedAt: now - minutes * 60000,
+    clockAdvancedAt: now, clockAdvanceMinutes: minutes,
+    clockRunningProof: {first: first.reason, second: second.reason,
+      userKey: run.newUserKey, observedAt: second.observedAt}});
+  return {status: "ADVANCED_WHILE_RUNNING", minutes, tabId,
+    firstReason: first.reason, secondReason: second.reason};
+}
+const isAction = (sender, message, run) => {
+  if (!Number.isInteger(sender.tab?.id) || typeof sender.url !== "string") return false;
+  try {
+    const file = run?.action === "HANDOFF" ? "handoff.html" : "continue.html";
+    const u = new URL(sender.url);
+    const manual = Number.isInteger(run?.manualActionTabId)
+      && run.manualActionTabId === sender.tab.id && !u.searchParams.has("token")
+      && (!u.searchParams.has("tabId") || u.searchParams.get("tabId") === String(message.tabId));
+    return u.origin === new URL(chrome.runtime.getURL(file)).origin
+      && u.pathname === "/" + file
+      && (manual || u.searchParams.get("token") === message.token
+        && u.searchParams.get("tabId") === String(message.tabId));
+  } catch { return false; }
+};
+async function onTake(message, sender) {
+  const run = await readRun();
+  if (!isAction(sender, message, run)) return {status: "DENIED", code: "ACTION_SOURCE_INVALID"};
+  if (run?.countMode && run.action === "CONTINUE" && !run.testSetup
+    && Date.now() < run.countLastSendAt + COUNT_INTERVAL_MS)
+    return {status:"DENIED",code:"COUNT_INTERVAL_NOT_DUE"};
+  if (run?.phase !== "RESERVED" || run.token !== message.token
+    || run.tabId !== message.tabId) return {status: "DENIED", code: "ACTION_NOT_RESERVED"};
+  const tab = await chrome.tabs.get(run.tabId).catch(() => null);
+  if (!tab || (run.testSetup ? tab.url !== "https://chatgpt.com/" : pathOf(tab.url) !== run.page)) {
+    await saveRun({...run, phase: "BLOCKED", reason: "CHAT_TARGET_CHANGED"});
+    return {status: "DENIED", code: "CHAT_TARGET_CHANGED"};
+  }
+  await saveRun({...run, phase: "PENDING"});
+  return {status: "OK", action: run.action || "CONTINUE",
+    handoffMode: run.handoffMode || null, retryMode: run.retryMode || null,
+    countMode: run.countMode === true,
+    countValue: run.countMode ? run.countValue : null,
+    target: {tabId: run.tabId, page: run.page,
+      assistantKey: run.assistantKey,
+      userKey: run.retryMode === "NATIVE" || run.handoffMode === "ERROR"
+        ? run.newUserKey : run.userKey,
+      testSetup: run.testSetup === true, discardDraft: run.discardDraft === true},
+    text: run.testSetup ? (run.countMode ? COUNT_SETUP_TEXT
+      : run.wallTestHours || run.wallTestMinutes === 10 ? ACTION_WALL_TEST_TEXT
+      : run.timedTest ? ACTION_TIMED_TEST_TEXT : ACTION_TEST_TEXT)
+      : run.action === "HANDOFF" ? run.handoffText || null
+      : run.countMode ? countText(run.countValue)
+      : run.timedTest && run.wallTestMinutes === 10
+        ? wallArithmeticText(run.testTurnIndex || 2) : CONTINUE_TEXT};
+}
+async function onResult(message, sender) {
+  const run = await readRun();
+  if (!isAction(sender, message, run)) return {status: "DENIED", code: "ACTION_SOURCE_INVALID"};
+  if (run?.phase !== "PENDING" || run.token !== message.token)
+    return {status: "DENIED", code: "ACTION_NOT_PENDING"};
+  // Native Retry does not submit another user message. One-time click is
+  // confirmed separately and re-arms the already-owned pending user Turn.
+  if (run.retryMode === "NATIVE") {
+    const tab = await chrome.tabs.get(run.tabId).catch(() => null);
+    const confirmedRetry = message.result === "RETRY_CLICKED" && tab
+      && pathOf(tab.url) === run.page && run.retryCount === 1;
+    const nextRetry = {...run, phase: confirmedRetry ? "WAITING_REPLY" : "BLOCKED",
+      reason: confirmedRetry ? "" : "RETRY_UNVERIFIED"};
+    delete nextRetry.retryMode;
+    await saveRun(nextRetry);
+    if (confirmedRetry) {
+      const reset = await chrome.tabs.sendMessage(run.tabId,
+        {type: "CHAT_LOOP_TURN_RETRY_MONITOR_V1", page: run.page,
+          userKey: run.newUserKey}).catch(() => null);
+      if (reset?.status !== "REARMED") {
+        await saveRun({...nextRetry, phase: "BLOCKED", reason: "RETRY_OBSERVER_UNVERIFIED"});
+        return {status: "BLOCKED", code: "RETRY_OBSERVER_UNVERIFIED"};
+      }
+    }
+    return {status: confirmedRetry ? "OK" : "BLOCKED"};
+  }
+  let confirmed = message.result === "SENT_CONFIRMED"
+    && typeof message.newUserKey === "string"
+    && /^user:[^\s]{8,}$/.test(message.newUserKey)
+    && message.newUserKey !== run.userKey;
+  const failure = typeof message.reason === "string" && /^[A-Z0-9_]{4,100}$/.test(message.reason)
+    ? message.reason : "SEND_UNVERIFIED";
+  let next = {...run, phase: "BLOCKED", reason: failure};
+  // Diagnostic only: retain the possibly-created target without granting ownership.
+  if (run.action === "HANDOFF" && Number.isInteger(message.newTabId))
+    next.attemptedNewTabId = message.newTabId;
+  if (confirmed && run.action === "HANDOFF") {
+    const newTab = Number.isInteger(message.newTabId)
+      ? await chrome.tabs.get(message.newTabId).catch(() => null) : null;
+    confirmed = Boolean(newTab && message.newTabId !== run.tabId
+      && pathOf(newTab.url) && pathOf(newTab.url) === message.newPage);
+    if (confirmed) {
+      // Transfer the single loop owner. The old Chat remains open for audit.
+      next = {...run, action: "HANDOFF", sourceTabId: run.tabId,
+        sourcePage: run.page, tabId: newTab.id, page: message.newPage,
+        // Keep source identities as the already-processed baseline; the new
+        // user's first reply must not be suppressed by duplicate detection.
+        newUserKey: message.newUserKey, phase: "WAITING_REPLY", reason: "",
+        // The new Chat has no previous assistant message. Never authenticate
+        // its first Retry/Error Handoff using the OLD Chat's assistant ID.
+        userKey: null, assistantKey: null, startedAt: Date.now(),
+        errorHandoffCount: run.handoffMode === "ERROR" ? (run.errorHandoffCount || 0) + 1 : 0,
+        ...(run.countMode ? {countMode:true, countValue:run.countValue,
+          countHandoffs:(run.countHandoffs || 0) + 1,
+          countLastSendAt:Date.now()} : {})};
+      delete next.handoffText;
+      delete next.errorReason;
+      delete next.handoffPending;
+      delete next.handoffPendingAt;
+      delete next.deadlineAt;
+    }
+  } else if (confirmed && run.testSetup) {
+    const tab = await chrome.tabs.get(run.tabId).catch(() => null);
+    confirmed = Boolean(tab && pathOf(tab.url) && pathOf(tab.url) === message.newPage);
+    if (confirmed) {
+      next = {...run, page: message.newPage, phase: "WAITING_REPLY", reason: "",
+        newUserKey: message.newUserKey,
+        ...(run.wallTestMinutes === 10 ? {testTurnIndex: 1} : {}),
+        ...(run.countMode ? {countLastSendAt:Date.now()} : {}),
+        ...(run.wallTestHours ? {startedAt: Date.now()} : {})};
+      delete next.testSetup;
+      delete next.discardDraft;
+    }
+  } else if (confirmed) {
+    next = {...run, phase: "WAITING_REPLY", reason: "",
+      newUserKey: message.newUserKey,
+      ...(run.countMode ? {countLastSendAt:Date.now()} : {})};
+  }
+  await saveRun(next);
+  return {status: confirmed ? "OK" : "BLOCKED"};
+}
+// Extension updates invalidate previous injected listeners. Reconnect only its own observers.
+async function reconnectOpenChats() {
+  const tabs = await chrome.tabs.query({url: "https://chatgpt.com/*"});
+  for (const tab of tabs) {
+    if (!Number.isInteger(tab.id) || !pathOf(tab.url) && !/^https:\/\/chatgpt\.com\/$/.test(tab.url)) continue;
+    try {
+      await chrome.scripting.executeScript({target: {tabId: tab.id},
+        files: ["content.js", "loop/observer.js"]});
+      const owner = await readRun();
+      if (owner?.phase === "WAITING_REPLY" && owner.tabId === tab.id
+        && owner.page === pathOf(tab.url) && owner.newUserKey) {
+        const res = await chrome.tabs.sendMessage(tab.id, {
+          type: "CHAT_LOOP_TURN_RESUME_V1", page: owner.page,
+          userKey: owner.newUserKey, assistantKey: owner.assistantKey || null,
+          startedAt: owner.startedAt
+        }).catch(() => null);
+        if (res?.status !== "RESUMED" && res?.status !== "ALREADY_MONITORING")
+          console.warn("Chat Loop pending Turn resume not yet verified:", res?.reason || res?.status);
+      }
+    } catch (error) {console.warn("Chat Loop observer reconnect unavailable:", error?.message);}
+  }
+}
+async function releaseWallClockHold(run) {
+  const liveRun = await readRun();
+  if (liveRun?.phase !== "WALL_CLOCK_HOLD" || liveRun.tabId !== run?.tabId
+    || liveRun.wallHoldAt !== run?.wallHoldAt
+    || liveRun.userKey !== run?.userKey) return {status: "IGNORED", code: "HOLD_ALREADY_CHANGED"};
+  if (run?.phase !== "WALL_CLOCK_HOLD" || !([1, 2].includes(run.wallTestHours)
+    || run.wallTestMinutes === 10)
+    || !run.timedTest || !Number.isSafeInteger(run.wallReleaseAt)
+    || Date.now() < run.wallReleaseAt) return {status: "NOT_DUE"};
+  const owned = (await chrome.storage.local.get("chat-loop.acceptance.owned.v1"))[
+    "chat-loop.acceptance.owned.v1"];
+  if (!Array.isArray(owned) || !owned.some(t => t.id === run.tabId))
+    return {status: "DENIED", code: "NOT_TEST_OWNED"};
+  const tab = await chrome.tabs.get(run.tabId).catch(() => null);
+  if (!tab || pathOf(tab.url) !== run.page) {
+    await saveRun({...run, phase: "BLOCKED", reason: "WALL_CHAT_CHANGED"});
+    return {status: "BLOCKED", code: "WALL_CHAT_CHANGED"};
+  }
+  const verify = async () => {
+    const p = await chrome.tabs.sendMessage(run.tabId,
+      {type: "CHAT_LOOP_TURN_VERIFY_V1"}).catch(() => null);
+    return p?.contract === "chat-loop.turn-observer.v1" && p.status === "READY"
+      && p.page === run.page && p.userKey === run.userKey
+      && p.assistantKey === run.assistantKey
+      && globalThis.ChatLoopCoreV1.parseStatus(p.replyText) === "CONTINUE";
+  };
+  if (!await verify()) return {status: "UNVERIFIED", code: "WALL_TURN_NOT_STABLE"};
+  await new Promise(resolve => setTimeout(resolve, 2300));
+  if (!await verify()) return {status: "UNVERIFIED", code: "WALL_TURN_CHANGED"};
+  const latest = await readRun();
+  if (latest?.phase !== "WALL_CLOCK_HOLD" || latest.tabId !== run.tabId
+    || latest.userKey !== run.userKey || latest.wallHoldAt !== run.wallHoldAt)
+    return {status: "IGNORED", code: "HOLD_CHANGED_DURING_VERIFICATION"};
+  const token = crypto.randomUUID();
+  const next = {...run, phase: "RESERVED", action: "CONTINUE", token,
+    wallReleasedAt: Date.now(), reason: ""};
+  await saveRun(next); // reserve once, then Action page exclusively sends
+  try {
+    const action = await chrome.tabs.create({
+      url: chrome.runtime.getURL("continue.html") + "?tabId=" + run.tabId
+        + "&token=" + encodeURIComponent(token), active: false, windowId: tab.windowId
+    });
+    return {status: "QUEUED", actionTabId: action.id};
+  } catch {
+    await saveRun({...next, phase: "BLOCKED", reason: "WALL_ACTION_CREATE_FAILED"});
+    return {status: "BLOCKED", code: "WALL_ACTION_CREATE_FAILED"};
+  }
+}
+// MV3 background service workers can suspend, and hidden-page setInterval
+// may be throttled. An alarm asks the Observer to sample, never acts directly.
+async function ensureAlarm() {
+  if (!chrome.alarms?.create) return;
+  const existing = await chrome.alarms.get?.(ALARM_NAME).catch(() => null);
+  if (!existing) await chrome.alarms.create(ALARM_NAME, {periodInMinutes: 1});
+}
+async function watchActiveTurn() {
+  // Normal periodic wakeups also reconcile a delayed one-shot deadline.
+  // All state changes share the same serial queue as Turn/Action receipts.
+  await serial(prepareHandoffIfDue);
+  const run = await readRun();
+  // While an Action is pending, never dispatch competing operations.
+  if (run?.phase === "WALL_CLOCK_HOLD") {
+    void serial(() => releaseWallClockHold(run));
+    return;
+  }
+  if (run?.phase === "WAITING_INTERVAL") {
+    void serial(releaseCountInterval);
+    return;
+  }
+  if (run && ["RESERVED", "PENDING"].includes(run.phase)) return;
+  const tabs = run?.phase === "WAITING_REPLY"
+    ? [await chrome.tabs.get(run.tabId).catch(() => null)]
+    : await chrome.tabs.query({url: "https://chatgpt.com/*"});
+  for (const tab of tabs) {
+    if (!tab?.id || !pathOf(tab.url)) continue;
+    try {
+      const proof = await chrome.tabs.sendMessage(tab.id,
+        {type: "CHAT_LOOP_TURN_OBSERVE_V1", poll: true});
+      // A reloaded Observer may have mistaken the in-flight user Turn for
+      // historical baseline. Its IDLE state is not proof of completion.
+      // Rebind the exact persisted owner using read-only verification.
+      if (run?.phase === "WAITING_REPLY" && run.tabId === tab.id
+        && proof?.page === run.page && proof.userKey === run.newUserKey
+        && (proof.status === "IDLE"
+          || proof.status === "UNKNOWN"
+            && ["ATTACHING_CHAT", "WAITING_CHAT_HYDRATION"].includes(proof.reason))) {
+        await chrome.tabs.sendMessage(tab.id, {
+          type: "CHAT_LOOP_TURN_RESUME_V1", page: run.page,
+          userKey: run.newUserKey, assistantKey: run.assistantKey || null,
+          startedAt: run.startedAt
+        }).catch(() => null);
+      }
+      // Alarm is still read-only. It may reconcile a verified page failure if
+      // the observer's original notification was lost while Worker slept.
+      if (run?.phase === "WAITING_REPLY" && run.tabId === tab.id
+        && proof?.status === "BLOCKED" && proof.reason === "PAGE_ERROR"
+        && proof.page === run.page && proof.userKey === run.newUserKey) {
+        void serial(() => onTurnBlocked({page: run.page,
+          userKey: run.newUserKey, reason: "PAGE_ERROR"},
+        {tab, url: tab.url}));
+      }
+    } catch { /* Observer unavailable; never infer Turn completion. */ }
+  }
+}
+chrome.alarms?.onAlarm?.addListener(alarm => {
+  if (alarm?.name === ALARM_NAME) void watchActiveTurn();
+  if (alarm?.name === DEADLINE_ALARM_NAME)
+    void serial(async () => {await prepareHandoffIfDue();await releaseCountInterval();});
+  if (alarm?.name === COUNT_ALARM_NAME) void serial(releaseCountInterval);
+});
+chrome.runtime.onInstalled?.addListener(() => {
+  void ensureAlarm();
+  void reconnectOpenChats();
+});
+chrome.runtime.onStartup?.addListener(() => {
+  void ensureAlarm();
+  void reconnectOpenChats();
+});
+void ensureAlarm();
+// Reconcile an elapsed deadline after MV3 Worker suspension/reload.
+void serial(prepareHandoffIfDue);
+// A manual extension Reload does not necessarily fire onInstalled/onStartup.
+// Reattach the two idempotent read-only scripts to existing ChatGPT tabs.
+void reconnectOpenChats();
+// Read-only target resolver for a CLI-created formal Eye Action.
+// This never starts a Loop, changes Owner, or sends a chat message.
+async function onExtensionCliTarget(message,sender) {
+  const pages={chat_text:"text.html",chat_dom:"dom.html",
+    chat_screenshot:"screenshot.html",reload:"reload.html"};
+  const page=pages[message?.action];
+  if(!page || !/^[a-f0-9]{32}$/.test(message?.id||"")
+    || sender.url !== chrome.runtime.getURL(page)+"?requestId="+message.id)
+    return {status:"DENIED",code:"INVALID_EXTENSION_ACTION_SOURCE"};
+  if(message.action==="reload")return {status:"OK"};
+  const run=await readRun();
+  if(run?.phase!=="WAITING_REPLY" || !Number.isInteger(run.tabId)
+    || typeof run.page!=="string")
+    return {status:"DENIED",code:"NO_ACTIVE_CHAT_OWNER"};
+  const tab=await chrome.tabs.get(run.tabId).catch(()=>null);
+  if(!tab || pathOf(tab.url)!==run.page)
+    return {status:"DENIED",code:"OWNER_CHANGED"};
+  return {status:"OK",tabId:run.tabId,page:run.page};
+}
+chrome.runtime.onMessage.addListener((message, sender, reply) => {
+  const type = message?.type;
+  if (["CHAT_LOOP_TURN_FINISHED_V1", "CHAT_LOOP_TURN_BLOCKED_V1",
+    "CHAT_LOOP_ACTION_TAKE_V1",
+    "CHAT_LOOP_ACTION_RESULT_V1", "CHAT_LOOP_ACTION_MANUAL_PREPARE_V1",
+    "CHAT_LOOP_ACTION_TEST_PREPARE_V1",
+    "CHAT_LOOP_ACCEPTANCE_CLOCK_ADVANCE_V1"].includes(type)) {
+    const work = serial(() => type === "CHAT_LOOP_TURN_FINISHED_V1"
+      ? onTurnFinished(message, sender) : type === "CHAT_LOOP_TURN_BLOCKED_V1"
+        ? onTurnBlocked(message, sender) : type === "CHAT_LOOP_ACTION_TAKE_V1"
+        ? onTake(message, sender) : type === "CHAT_LOOP_ACTION_MANUAL_PREPARE_V1"
+          ? onManualPrepare(message, sender) : type === "CHAT_LOOP_ACTION_TEST_PREPARE_V1"
+            ? onTestPrepare(message, sender)
+          : type === "CHAT_LOOP_ACCEPTANCE_CLOCK_ADVANCE_V1"
+            ? onAcceptanceClockAdvance(message, sender) : onResult(message, sender));
+    void work.then(reply, error => reply({status: "BLOCKED", code: error.message || "SCHEDULER_ERROR"}));
+    return true;
+  }
+  if (type === "CHAT_LOOP_EXTENSION_TARGET_V1") {
+    void onExtensionCliTarget(message,sender).then(reply,
+      ()=>reply({status:"DENIED",code:"OWNER_UNVERIFIED"}));
+    return true;
+  }
+  if (type !== "CHAT_LOOP_EYE_RELOAD_V1") return false;
+  const id = sender.tab?.id;
+  void (async () => {
+    try {
+      if (!Number.isInteger(id)) throw Error("NO_ACTION_TAB");
+      const tab = await chrome.tabs.get(id);
+      const reloadBase=chrome.runtime.getURL("reload.html");
+      if (!tab.url.startsWith(reloadBase) ||
+        (tab.url!==reloadBase &&
+          !/^\?requestId=[a-f0-9]{32}$/.test(tab.url.slice(reloadBase.length))))
+        throw Error("INVALID_RELOAD_SOURCE");
+      reply({status: "ACCEPTED"});
+      await chrome.tabs.remove(id);
+      chrome.runtime.reload();
+    } catch (error) {reply({status: "FAILED", code: error.message});}
+  })();
+  return true;
+});