@tomflow/proflow-execution-browser-extension 0.1.36 → 0.1.38

package/dist/extension/background.js

@@ -4,6 +4,248 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// packages/execution-browser-extension/src/carrier-attention.ts
+function createCarrierAttentionRegistry(idFactory = () => crypto.randomUUID()) {
+  const byTab = /* @__PURE__ */ new Map();
+  return Object.freeze({
+    derive(input) {
+      const current = byTab.get(input.tabId);
+      if (current?.contentInstanceId === input.contentInstanceId && current.url === input.url && current.permissionFingerprint === input.permissionFingerprint) {
+        const refreshed = { ...current, ...input };
+        byTab.set(input.tabId, refreshed);
+        return refreshed;
+      }
+      const occurrenceRef = idFactory();
+      const attention = {
+        ...input,
+        occurrenceRef,
+        attentionRef: `carrier-attention:${input.tabId}:${occurrenceRef}`
+      };
+      byTab.set(input.tabId, attention);
+      return attention;
+    },
+    find(attentionRef) {
+      for (const attention of byTab.values())
+        if (attention.attentionRef === attentionRef) return attention;
+      return null;
+    },
+    current(tabId) {
+      return byTab.get(tabId) ?? null;
+    },
+    values() {
+      return [...byTab.values()];
+    },
+    delete(attentionRef) {
+      for (const [tabId, attention] of byTab)
+        if (attention.attentionRef === attentionRef) return byTab.delete(tabId);
+      return false;
+    },
+    removeTab(tabId) {
+      return byTab.delete(tabId);
+    }
+  });
+}
+
+// packages/execution-browser-extension/src/carrier-continuation-control.ts
+function parseDenials(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.length > 128) return null;
+  const parsed = [];
+  for (const item of value) {
+    if (typeof item !== "object" || item === null || Array.isArray(item))
+      return null;
+    const attentionRef = Reflect.get(item, "attentionRef");
+    const tabId = Reflect.get(item, "tabId");
+    const taskId = Reflect.get(item, "taskId");
+    const roleRef = Reflect.get(item, "roleRef");
+    const workerRef = Reflect.get(item, "workerRef");
+    const url2 = Reflect.get(item, "url");
+    const contentInstanceId = Reflect.get(item, "contentInstanceId");
+    const permissionFingerprint = Reflect.get(item, "permissionFingerprint");
+    if (typeof attentionRef !== "string" || !Number.isInteger(tabId) || taskId !== null && typeof taskId !== "string" || roleRef !== null && typeof roleRef !== "string" || workerRef !== null && typeof workerRef !== "string" || typeof url2 !== "string" || typeof contentInstanceId !== "string" || typeof permissionFingerprint !== "string")
+      return null;
+    parsed.push({
+      attentionRef,
+      tabId,
+      taskId,
+      roleRef,
+      workerRef,
+      url: url2,
+      contentInstanceId,
+      permissionFingerprint
+    });
+  }
+  return parsed;
+}
+function createCarrierContinuationControl(initial) {
+  const byTab = /* @__PURE__ */ new Map();
+  const load = (value) => {
+    const denials = parseDenials(value);
+    byTab.clear();
+    if (!denials) return false;
+    for (const denial of denials) byTab.set(denial.tabId, denial);
+    return true;
+  };
+  if (initial !== void 0) load(initial);
+  return Object.freeze({
+    beginDenied(denial) {
+      byTab.set(denial.tabId, { ...denial });
+    },
+    cancelDenied(attentionRef) {
+      for (const [tabId, denial] of byTab)
+        if (denial.attentionRef === attentionRef) return byTab.delete(tabId);
+      return false;
+    },
+    hasMatchingPermissionDenial(context) {
+      const denial = byTab.get(context.tabId);
+      return denial?.contentInstanceId === context.contentInstanceId && denial.url === context.url && denial.permissionFingerprint === context.permissionFingerprint && denial.taskId === context.taskId && denial.roleRef === context.roleRef && denial.workerRef === context.workerRef;
+    },
+    hasMatchingDispatchDenial(context) {
+      if (context.conversationLocator === null) return false;
+      for (const denial of byTab.values())
+        if (denial.taskId === context.taskId && denial.roleRef === context.roleRef && denial.workerRef === context.workerRef && denial.url === context.conversationLocator)
+          return true;
+      return false;
+    },
+    consumeRecovery(previous, current) {
+      const denial = byTab.get(current.tabId);
+      if (!denial) return null;
+      if (denial.url !== current.url || denial.contentInstanceId !== current.contentInstanceId) {
+        byTab.delete(current.tabId);
+        return null;
+      }
+      if (current.pageState !== "IDLE") return null;
+      if (previous && (previous.tabId !== denial.tabId || previous.url !== denial.url || previous.contentInstanceId !== denial.contentInstanceId || previous.pageState !== "BLOCKED" || previous.blockerFacts?.fingerprint !== denial.permissionFingerprint)) {
+        byTab.delete(current.tabId);
+        return null;
+      }
+      byTab.delete(current.tabId);
+      return { ...denial };
+    },
+    suppressRecovery(previous, current) {
+      return this.consumeRecovery(previous, current) !== null;
+    },
+    snapshot() {
+      return [...byTab.values()].map((denial) => ({ ...denial }));
+    },
+    load
+  });
+}
+
+// packages/execution-browser-extension/src/carrier-permission-attempt.ts
+function parsedAttempts(value) {
+  const result = /* @__PURE__ */ new Map();
+  if (value === void 0) return { attempts: result, valid: true };
+  if (!Array.isArray(value)) return { attempts: result, valid: false };
+  let valid = value.length <= 256;
+  for (const candidate of value.slice(0, 256)) {
+    if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) {
+      valid = false;
+      continue;
+    }
+    const tabId = Reflect.get(candidate, "tabId");
+    const key = Reflect.get(candidate, "key");
+    if (!Number.isInteger(tabId) || tabId < 0 || typeof key !== "string" || key.length === 0 || key.length > 1e3) {
+      valid = false;
+      continue;
+    }
+    if (result.has(tabId)) valid = false;
+    result.set(tabId, key);
+  }
+  return { attempts: result, valid };
+}
+function createCarrierPermissionAttemptRegistry(initial) {
+  const attempts = parsedAttempts(initial).attempts;
+  return Object.freeze({
+    has(tabId, key) {
+      return attempts.get(tabId) === key;
+    },
+    begin(tabId, key) {
+      attempts.set(tabId, key);
+    },
+    release(tabId, key) {
+      if (attempts.get(tabId) !== key) return false;
+      return attempts.delete(tabId);
+    },
+    observe(tabId, currentKey) {
+      const attempted = attempts.get(tabId);
+      if (attempted === void 0 || attempted === currentKey) return false;
+      return attempts.delete(tabId);
+    },
+    load(value) {
+      const parsed = parsedAttempts(value);
+      attempts.clear();
+      for (const [tabId, key] of parsed.attempts) attempts.set(tabId, key);
+      return parsed.valid;
+    },
+    snapshot() {
+      return [...attempts].map(([tabId, key]) => ({ tabId, key }));
+    }
+  });
+}
+
+// packages/execution-browser-extension/src/carrier-permission-lifecycle.ts
+async function resolveRoutineCarrierPermission(input) {
+  const denied = () => input.humanDenied?.() ? { status: "HUMAN_REQUIRED", reason: "HUMAN_DENIED" } : null;
+  const maxClassifications = Math.max(1, input.maxClassifications ?? 40);
+  let decision = null;
+  for (let attempt = 0; attempt < maxClassifications; attempt += 1) {
+    const beforeClassification = denied();
+    if (beforeClassification) return beforeClassification;
+    try {
+      decision = await input.port.classify();
+    } catch {
+      return {
+        status: "HUMAN_REQUIRED",
+        reason: "PERMISSION_CLASSIFICATION_FAILED"
+      };
+    }
+    const afterClassification = denied();
+    if (afterClassification) return afterClassification;
+    if (decision.decision !== "DEFER") break;
+    if (!await input.port.revalidate()) return { status: "STALE" };
+    if (attempt === maxClassifications - 1)
+      return {
+        status: "HUMAN_REQUIRED",
+        reason: "PERMISSION_CONTEXT_DEFER_TIMEOUT"
+      };
+    await input.port.waitBeforeReclassify?.();
+  }
+  if (!decision)
+    return {
+      status: "HUMAN_REQUIRED",
+      reason: "PERMISSION_CLASSIFICATION_FAILED"
+    };
+  if (decision.decision !== "AUTO_ALLOW")
+    return { status: "HUMAN_REQUIRED", reason: decision.reason };
+  if (!input.facts.actions.includes("allowAlways"))
+    return {
+      status: "HUMAN_REQUIRED",
+      reason: "AUTO_ALLOW_ACTION_UNAVAILABLE"
+    };
+  if (input.autoAlreadyAttempted)
+    return {
+      status: "HUMAN_REQUIRED",
+      reason: "AUTO_ALLOW_REALITY_UNCONFIRMED"
+    };
+  if (!await input.port.revalidate()) return { status: "STALE" };
+  const beforeAction = denied();
+  if (beforeAction) return beforeAction;
+  try {
+    await input.port.act("allowAlways");
+  } catch {
+    return { status: "HUMAN_REQUIRED", reason: "AUTO_ALLOW_FAILED" };
+  }
+  return await input.port.released() ? { status: "RELEASED", action: "allowAlways" } : { status: "HUMAN_REQUIRED", reason: "AUTO_ALLOW_REALITY_UNCONFIRMED" };
+}
+async function resolveHumanCarrierPermission(input) {
+  if (!await input.revalidate()) throw new Error("STALE_PERMISSION");
+  await input.act(input.action);
+  if (!await input.released())
+    throw new Error("PERMISSION_ACTION_REALITY_UNCONFIRMED");
+  return "RELEASED";
+}
+
 // node_modules/.pnpm/zod@4.1.12/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -13544,6 +13786,13 @@ function createCollaborationCarrierApplication(options) {
   return Object.freeze({ deliverMessage, recoverPending });
 }
 
+// packages/execution-browser-extension/src/recovery-trigger.ts
+function shouldTriggerObserverRecovery(previous, current) {
+  if (current.pageState !== "IDLE") return false;
+  if (!previous) return true;
+  return previous.pageState !== "IDLE" || previous.url !== current.url || previous.contentInstanceId !== current.contentInstanceId || previous.activityKind !== current.activityKind;
+}
+
 // packages/execution-browser-extension/src/system-observer.ts
 var SYSTEM_OBSERVER_VIEWS = [
   "task",
@@ -13866,33 +14115,61 @@ function createTaskObserver(options) {
   return Object.freeze({ advance, drive });
 }
 
-// packages/execution-browser-extension/src/recovery-trigger.ts
-function shouldTriggerObserverRecovery(previous, current) {
-  if (current.pageState !== "IDLE") return false;
-  if (!previous) return true;
-  return previous.pageState !== "IDLE" || previous.url !== current.url || previous.contentInstanceId !== current.contentInstanceId || previous.activityKind !== current.activityKind;
-}
-
 // packages/execution-browser-extension/extension/background.ts
 var extensionInstanceId = `extension:${crypto.randomUUID()}`;
 var sessions = /* @__PURE__ */ new Map();
+var permissionHandling = /* @__PURE__ */ new Map();
+var permissionAutoAttempts = createCarrierPermissionAttemptRegistry();
+var carrierAttentions = createCarrierAttentionRegistry();
+var carrierContinuationControl = createCarrierContinuationControl();
 var BROWSER_CARRIER_KEEPALIVE_KEY = "proflowBrowserSnapshot";
 var BROWSER_CARRIER_KEEPALIVE_MS = 2e4;
 var BROWSER_BRIDGE_FETCH_TIMEOUT_MS = 5e3;
+var snapshotPersistence = Promise.resolve();
+var transientPermissionAttemptsRestore = null;
 var sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-async function persistSnapshot() {
-  await chrome.storage.session.set({
+function persistSnapshot() {
+  const value = {
     proflowBrowserSnapshot: {
       extensionInstanceId,
       observedAt: (/* @__PURE__ */ new Date()).toISOString(),
       sessions: [...sessions.values()],
+      permissionAutoAttempts: permissionAutoAttempts.snapshot(),
+      carrierContinuationDenials: carrierContinuationControl.snapshot(),
       recoveryScan: "BOUNDED_ON_START"
     }
-  });
+  };
+  snapshotPersistence = snapshotPersistence.catch(() => void 0).then(() => chrome.storage.session.set(value));
+  return snapshotPersistence;
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function restoreTransientPermissionAttempts() {
+  if (transientPermissionAttemptsRestore)
+    return transientPermissionAttemptsRestore;
+  transientPermissionAttemptsRestore = (async () => {
+    try {
+      const stored = await chrome.storage.session.get(
+        BROWSER_CARRIER_KEEPALIVE_KEY
+      );
+      const snapshot = stored[BROWSER_CARRIER_KEEPALIVE_KEY];
+      const validSnapshot = isRecord(snapshot);
+      const attemptsLoaded = permissionAutoAttempts.load(
+        validSnapshot ? snapshot.permissionAutoAttempts : void 0
+      );
+      const denialsLoaded = carrierContinuationControl.load(
+        validSnapshot ? snapshot.carrierContinuationDenials : void 0
+      );
+      return attemptsLoaded && denialsLoaded;
+    } catch {
+      permissionAutoAttempts.load(void 0);
+      carrierContinuationControl.load(void 0);
+      return false;
+    }
+  })();
+  return transientPermissionAttemptsRestore;
+}
 function parseConfig(value) {
   if (!isRecord(value)) return null;
   const endpoint = value.endpoint;
@@ -14104,6 +14381,8 @@ var taskObserver = createTaskObserver({
   },
   carrier: {
     async requestWake(input) {
+      if (carrierContinuationControl.hasMatchingDispatchDenial(input))
+        throw new Error("CARRIER_CONTINUATION_HUMAN_DENIED");
       return invokeObserverApplication("task.wake", input);
     }
   }
@@ -14197,8 +14476,14 @@ async function persistSystemObserverState(result) {
 }
 var observerRecoveryInFlight = null;
 var observerRecoveryRetryCount = 0;
+var nextRecoverySuppressions = [];
+function suppressNextObserverRecovery(denials) {
+  nextRecoverySuppressions = denials;
+}
 function runObserverRecovery() {
   if (observerRecoveryInFlight) return observerRecoveryInFlight;
+  const suppressedContinuations = nextRecoverySuppressions;
+  nextRecoverySuppressions = [];
   observerRecoveryInFlight = (async () => {
     let recoveryNeedsRetry = false;
     await collaborationCarrier.recoverPending(50).catch(() => void 0);
@@ -14211,6 +14496,10 @@ function runObserverRecovery() {
         if (!isRecord(candidate) || typeof candidate.signalRef !== "string" || typeof candidate.executionRef !== "string" || typeof candidate.taskId !== "string" || typeof candidate.workerRef !== "string")
           continue;
         try {
+          if (suppressedContinuations.some(
+            (denial) => denial.taskId === candidate.taskId && denial.workerRef === candidate.workerRef
+          ))
+            continue;
           const decision = candidate.kind === "RECOVERY_RESUME" ? await taskObserver.drive(candidate.taskId, {
             trigger: "RECOVERY_RESUME",
             ref: candidate.executionRef,
@@ -14249,6 +14538,10 @@ function runObserverRecovery() {
         }).catch(() => {
           recoveryNeedsRetry = true;
         });
+        if (suppressedContinuations.some(
+          (denial) => denial.taskId === candidate.taskId
+        ))
+          continue;
         await taskObserver.drive(candidate.taskId).catch(() => {
           recoveryNeedsRetry = true;
         });
@@ -14302,6 +14595,340 @@ async function contentCommand(tabId, command) {
   }
   return response.value;
 }
+function carrierIdentity(url2) {
+  try {
+    const parsed = new URL(url2);
+    const segments = parsed.pathname.split("/").filter(Boolean);
+    if (parsed.protocol !== "https:" || parsed.hostname !== "chatgpt.com" || segments[0] !== "g" || !segments[1]?.startsWith("g-"))
+      return null;
+    return {
+      roleRef: segments[1],
+      workerRef: segments[2] === "c" && segments[3] ? segments[3] : null
+    };
+  } catch {
+    return null;
+  }
+}
+function permissionAttemptKey(observed) {
+  return observed.blockerFacts ? `${observed.url}:${observed.blockerFacts.fingerprint}` : null;
+}
+function setCarrierAttention(observed, reason) {
+  const facts = observed.blockerFacts;
+  if (!facts) return;
+  const identity = carrierIdentity(observed.url);
+  carrierAttentions.derive({
+    tabId: observed.tabId,
+    contentInstanceId: observed.contentInstanceId,
+    url: observed.url,
+    permissionFingerprint: facts.fingerprint,
+    taskId: facts.taskId,
+    roleRef: identity?.roleRef ?? null,
+    workerRef: identity?.workerRef ?? null,
+    targetHost: facts.targetHost,
+    operationId: facts.operationId,
+    reason,
+    actions: facts.actions.filter(
+      (action) => action === "allowOnce" || action === "deny"
+    ),
+    observedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  void publishCarrierAttentions();
+}
+function carrierAttentionViews() {
+  return carrierAttentions.values().map(
+    ({
+      attentionRef,
+      occurrenceRef,
+      taskId,
+      roleRef,
+      workerRef,
+      targetHost,
+      operationId,
+      reason,
+      actions,
+      observedAt
+    }) => ({
+      attentionRef,
+      occurrenceRef,
+      taskId,
+      roleRef,
+      workerRef,
+      targetHost,
+      operationId,
+      reason,
+      actions,
+      observedAt
+    })
+  );
+}
+async function publishCarrierAttentions() {
+  const config2 = await bridgeConfig().catch(() => null);
+  if (!config2) return;
+  const query = `?extensionInstanceId=${encodeURIComponent(extensionInstanceId)}`;
+  const response = await bridgeFetch(config2, `/v1/carrier/attentions${query}`, {
+    method: "POST",
+    body: JSON.stringify({ carrierAttentions: carrierAttentionViews() })
+  });
+  if (!response.ok) throw new Error("CARRIER_ATTENTION_PUBLISH_REJECTED");
+}
+function rawPermissionFingerprint(value) {
+  if (!isRecord(value) || !isRecord(value.blockerFacts)) return null;
+  return typeof value.blockerFacts.fingerprint === "string" ? value.blockerFacts.fingerprint : null;
+}
+function parsePermissionFacts(value) {
+  if (!isRecord(value) || value.kind !== "ACTION_PERMISSION") return void 0;
+  const actions = value.actions;
+  if (value.targetHost !== null && typeof value.targetHost !== "string" || typeof value.operationId !== "string" || value.taskId !== null && typeof value.taskId !== "string" || !Array.isArray(actions) || actions.some(
+    (action) => action !== "allowAlways" && action !== "allowOnce" && action !== "deny"
+  ) || typeof value.fingerprint !== "string")
+    return void 0;
+  return {
+    kind: "ACTION_PERMISSION",
+    targetHost: value.targetHost,
+    operationId: value.operationId,
+    taskId: value.taskId,
+    actions: [...actions],
+    fingerprint: value.fingerprint
+  };
+}
+function parseSnapshotObservation(value, tab) {
+  if (!isRecord(value) || tab.id === void 0 || tab.windowId === void 0)
+    return null;
+  const pageState = value.pageState;
+  const activityKind = value.activityKind;
+  if (typeof value.url !== "string" || typeof value.contentInstanceId !== "string" || pageState !== "IDLE" && pageState !== "BUSY" && pageState !== "BLOCKED" && pageState !== "UNKNOWN" || activityKind !== null && activityKind !== "GENERATING" && activityKind !== "ACTION_PERMISSION" && activityKind !== "ACTION_RUNNING" && activityKind !== "WAITING_HUMAN" && activityKind !== "WAITING_PEER" && activityKind !== "RECOVERING" || typeof value.observedAt !== "string")
+    return null;
+  const blockerFacts = parsePermissionFacts(value.blockerFacts);
+  if (activityKind === "ACTION_PERMISSION" && blockerFacts === void 0)
+    return null;
+  return {
+    tabId: tab.id,
+    windowId: tab.windowId,
+    url: value.url,
+    contentInstanceId: value.contentInstanceId,
+    pageState,
+    activityKind,
+    ...blockerFacts ? { blockerFacts } : {},
+    observedAt: value.observedAt
+  };
+}
+async function waitForPermissionReleased(tabId, fingerprint) {
+  for (let attempt = 0; attempt < 40; attempt += 1) {
+    const current = sessions.get(tabId);
+    if (current && current.blockerFacts?.fingerprint !== fingerprint)
+      return true;
+    try {
+      const value = await contentCommand(tabId, { operation: "observe" });
+      if (rawPermissionFingerprint(value) !== fingerprint) return true;
+    } catch {
+    }
+    await sleep(250);
+  }
+  return false;
+}
+async function handleActionPermission(observed) {
+  const facts = observed.blockerFacts;
+  const key = permissionAttemptKey(observed);
+  if (observed.pageState !== "BLOCKED" || observed.activityKind !== "ACTION_PERMISSION" || !facts || !key)
+    return;
+  if (permissionHandling.get(observed.tabId) === key) return;
+  const existing = carrierAttentions.current(observed.tabId);
+  if (existing?.contentInstanceId === observed.contentInstanceId && existing.permissionFingerprint === facts.fingerprint)
+    return;
+  permissionHandling.set(observed.tabId, key);
+  try {
+    const identity = carrierIdentity(observed.url);
+    const humanDenied = () => carrierContinuationControl.hasMatchingPermissionDenial({
+      tabId: observed.tabId,
+      contentInstanceId: observed.contentInstanceId,
+      url: observed.url,
+      permissionFingerprint: facts.fingerprint,
+      taskId: facts.taskId,
+      roleRef: identity?.roleRef ?? null,
+      workerRef: identity?.workerRef ?? null
+    });
+    if (humanDenied()) {
+      setCarrierAttention(observed, "HUMAN_DENIED");
+      return;
+    }
+    if (!await restoreTransientPermissionAttempts()) {
+      setCarrierAttention(observed, "PERMISSION_ATTEMPT_STATE_UNAVAILABLE");
+      return;
+    }
+    if (!identity || !facts.taskId) {
+      setCarrierAttention(observed, "PERMISSION_CONTEXT_INCOMPLETE");
+      return;
+    }
+    const result = await resolveRoutineCarrierPermission({
+      facts,
+      autoAlreadyAttempted: permissionAutoAttempts.has(observed.tabId, key),
+      humanDenied,
+      port: {
+        async classify() {
+          const value = await invokeObserverApplication(
+            "browser.permission.classify",
+            {
+              taskId: facts.taskId,
+              roleRef: identity.roleRef,
+              ...identity.workerRef ? { workerRef: identity.workerRef } : {},
+              conversationLocator: observed.url,
+              targetHost: facts.targetHost,
+              operationId: facts.operationId
+            }
+          );
+          if (!isRecord(value) || value.decision !== "AUTO_ALLOW" && value.decision !== "DEFER" && value.decision !== "HUMAN_REQUIRED" || typeof value.reason !== "string")
+            return {
+              decision: "HUMAN_REQUIRED",
+              reason: "PERMISSION_CLASSIFICATION_INVALID"
+            };
+          return {
+            decision: value.decision,
+            reason: value.reason
+          };
+        },
+        revalidate() {
+          const current = observationFor(observed.tabId);
+          return current.contentInstanceId === observed.contentInstanceId && current.url === observed.url && current.blockerFacts?.fingerprint === facts.fingerprint;
+        },
+        waitBeforeReclassify: () => sleep(250),
+        async act(action) {
+          permissionAutoAttempts.begin(observed.tabId, key);
+          await persistSnapshot();
+          await contentCommand(observed.tabId, {
+            operation: "permissionAction",
+            permissionFingerprint: facts.fingerprint,
+            permissionAction: action
+          });
+        },
+        released: () => waitForPermissionReleased(observed.tabId, facts.fingerprint)
+      }
+    });
+    if (result.status === "RELEASED") {
+      permissionAutoAttempts.release(observed.tabId, key);
+      carrierAttentions.removeTab(observed.tabId);
+      void publishCarrierAttentions();
+      await persistSnapshot();
+      return;
+    }
+    if (result.status === "HUMAN_REQUIRED")
+      setCarrierAttention(observed, result.reason);
+  } catch {
+    setCarrierAttention(observed, "AUTO_ALLOW_FAILED");
+  } finally {
+    if (permissionHandling.get(observed.tabId) === key)
+      permissionHandling.delete(observed.tabId);
+  }
+}
+var carrierBlockerStrategies = /* @__PURE__ */ new Map([["ACTION_PERMISSION", handleActionPermission]]);
+function handleCarrierBlocker(observed) {
+  if (observed.pageState !== "BLOCKED" || observed.activityKind === null)
+    return;
+  const strategy = carrierBlockerStrategies.get(observed.activityKind);
+  if (strategy) void strategy(observed);
+}
+function processContentObservation(observed, triggerRecovery) {
+  const previous = sessions.get(observed.tabId);
+  sessions.set(observed.tabId, observed);
+  permissionAutoAttempts.observe(
+    observed.tabId,
+    permissionAttemptKey(observed)
+  );
+  const attention = carrierAttentions.current(observed.tabId);
+  if (attention && (observed.contentInstanceId !== attention.contentInstanceId || observed.url !== attention.url || observed.blockerFacts?.fingerprint !== attention.permissionFingerprint)) {
+    carrierAttentions.removeTab(observed.tabId);
+    void publishCarrierAttentions();
+  }
+  handleCarrierBlocker(observed);
+  const shouldRecover = triggerRecovery && shouldTriggerObserverRecovery(previous, observed);
+  const suppressed = shouldRecover && carrierContinuationControl.suppressRecovery(previous, observed);
+  void persistSnapshot();
+  if (shouldRecover && !suppressed) void runObserverRecovery();
+}
+async function rebuildCarrierAttentionsFromTabs() {
+  const consumedDenials = [];
+  const tabs = await chrome.tabs.query({ url: "https://chatgpt.com/g/*" });
+  for (const tab of tabs) {
+    if (tab.id === void 0 || tab.windowId === void 0) continue;
+    try {
+      const response = await chrome.tabs.sendMessage(tab.id, {
+        type: "PROFLOW_PAGE_SNAPSHOT_REQUEST"
+      });
+      if (!isRecord(response) || response.ok !== true) continue;
+      const observed = parseSnapshotObservation(response.value, tab);
+      if (observed) {
+        processContentObservation(observed, false);
+        const consumed = carrierContinuationControl.consumeRecovery(
+          void 0,
+          observed
+        );
+        if (consumed) consumedDenials.push(consumed);
+      }
+    } catch {
+    }
+  }
+  await persistSnapshot();
+  await publishCarrierAttentions().catch(() => void 0);
+  return [
+    ...consumedDenials,
+    ...carrierContinuationControl.snapshot().filter(
+      (denial) => !consumedDenials.some(
+        (consumed) => consumed.attentionRef === denial.attentionRef
+      )
+    )
+  ];
+}
+async function decideCarrierAttention(attentionRef, action) {
+  const attention = carrierAttentions.find(attentionRef);
+  if (!attention?.actions.includes(action))
+    throw new Error("CARRIER_ATTENTION_ACTION_DENIED");
+  await resolveHumanCarrierPermission({
+    action,
+    revalidate() {
+      const current = observationFor(attention.tabId);
+      return current.contentInstanceId === attention.contentInstanceId && current.url === attention.url && current.blockerFacts?.fingerprint === attention.permissionFingerprint;
+    },
+    async act(semanticAction) {
+      if (semanticAction === "deny") {
+        carrierContinuationControl.beginDenied({
+          attentionRef: attention.attentionRef,
+          tabId: attention.tabId,
+          taskId: attention.taskId,
+          roleRef: attention.roleRef,
+          workerRef: attention.workerRef,
+          url: attention.url,
+          contentInstanceId: attention.contentInstanceId,
+          permissionFingerprint: attention.permissionFingerprint
+        });
+        await persistSnapshot();
+      }
+      try {
+        await contentCommand(attention.tabId, {
+          operation: "permissionAction",
+          permissionFingerprint: attention.permissionFingerprint,
+          permissionAction: semanticAction
+        });
+      } catch (error46) {
+        if (semanticAction === "deny") {
+          carrierContinuationControl.cancelDenied(attention.attentionRef);
+          await persistSnapshot();
+        }
+        throw error46;
+      }
+    },
+    released: () => waitForPermissionReleased(
+      attention.tabId,
+      attention.permissionFingerprint
+    )
+  });
+  permissionAutoAttempts.release(
+    attention.tabId,
+    `${attention.url}:${attention.permissionFingerprint}`
+  );
+  carrierAttentions.delete(attention.attentionRef);
+  void publishCarrierAttentions();
+  await persistSnapshot();
+  return { attentionRef, action, status: "APPLIED" };
+}
 async function waitForSubmittedMessage(tabId, fingerprint) {
   for (let attempt = 0; attempt < 60; attempt += 1) {
     try {
@@ -14327,6 +14954,14 @@ function text(value, name) {
   return value;
 }
 async function executeCommand(command) {
+  if (command.type === "CARRIER_ATTENTION_ACTION") {
+    if (command.action !== "allowOnce" && command.action !== "deny")
+      throw new Error("ATTENTION_ACTION_INVALID");
+    return decideCarrierAttention(
+      text(command.attentionRef, "ATTENTION_REF"),
+      command.action
+    );
+  }
   if (command.type === "LIST_TABS") {
     const tabs = await chrome.tabs.query({ url: "https://chatgpt.com/g/*" });
     return tabs.map((tab) => tab.id).filter((tabId2) => tabId2 !== void 0).map((tabId2) => sessions.get(tabId2)).filter((value) => value !== void 0);
@@ -14520,6 +15155,7 @@ async function runBridgeLoop() {
         })
       });
       if (!hello.ok) throw new Error("BRIDGE_HELLO_REJECTED");
+      await publishCarrierAttentions();
       let lastHeartbeatAt = Date.now();
       let lastExtensionKeepaliveAt = Date.now();
       while (true) {
@@ -14709,16 +15345,12 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
     return true;
   }
   if (message.type === "PROFLOW_CONTENT_OBSERVATION" && message.observation && sender.tab?.id !== void 0 && sender.tab.windowId !== void 0) {
-    const previous = sessions.get(sender.tab.id);
     const observed = {
       ...message.observation,
       tabId: sender.tab.id,
       windowId: sender.tab.windowId
     };
-    sessions.set(sender.tab.id, observed);
-    void persistSnapshot();
-    if (shouldTriggerObserverRecovery(previous, observed))
-      void runObserverRecovery();
+    processContentObservation(observed, true);
     sendResponse({ accepted: true, extensionInstanceId });
     return;
   }
@@ -14732,6 +15364,7 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
         extensionInstanceId,
         observedAt: (/* @__PURE__ */ new Date()).toISOString(),
         sessions: [...sessions.values()],
+        carrierAttentions: carrierAttentionViews(),
         taskApplicationConfigured: application !== null,
         approvalApplicationConfigured: approval !== null,
         systemObserver: observerState ? {
@@ -14745,6 +15378,26 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
     );
     return true;
   }
+  if (message.type === "PROFLOW_CARRIER_ATTENTION_ACTION") {
+    if (!message.input) {
+      sendResponse({ ok: false, error: "CARRIER_ATTENTION_MESSAGE_INVALID" });
+      return;
+    }
+    const attentionRef = message.input.attentionRef;
+    const action = message.input.action;
+    if (typeof attentionRef !== "string" || action !== "allowOnce" && action !== "deny") {
+      sendResponse({ ok: false, error: "CARRIER_ATTENTION_MESSAGE_INVALID" });
+      return;
+    }
+    void decideCarrierAttention(attentionRef, action).then(
+      (value) => sendResponse({ ok: true, value }),
+      (error46) => sendResponse({
+        ok: false,
+        error: error46 instanceof Error ? error46.message : "CARRIER_ATTENTION_ACTION_FAILED"
+      })
+    );
+    return true;
+  }
   if (message.type === "PROFLOW_APPROVAL_APPLICATION") {
     if (typeof message.operation !== "string" || !message.input) {
       sendResponse({
@@ -14799,9 +15452,15 @@ async function openTaskPage() {
       const body = await response.json();
       if (response.ok && isRecord(body) && typeof body.url === "string" && body.url.startsWith(`${bridge.endpoint}/tasks/bootstrap/`)) {
         const webUrl = `${bridge.endpoint}/tasks`;
-        const [existing] = await chrome.tabs.query({ url: webUrl, currentWindow: true });
+        const [existing] = await chrome.tabs.query({
+          url: webUrl,
+          currentWindow: true
+        });
         if (existing?.id !== void 0) {
-          await chrome.tabs.update(existing.id, { url: body.url, active: true });
+          await chrome.tabs.update(existing.id, {
+            url: body.url,
+            active: true
+          });
         } else {
           await chrome.tabs.create({ url: body.url, active: true });
         }
@@ -14822,27 +15481,36 @@ async function openTaskPage() {
   await chrome.tabs.create({ url: fallbackUrl, active: true });
 }
 async function startBackgroundRuntime() {
+  await restoreTransientPermissionAttempts();
   await bootstrapManagedRuntimeConfig();
   await persistSnapshot();
   void runBridgeLoop();
   void runProvisioningBridgeLoop();
+  const suppressedContinuations = await rebuildCarrierAttentionsFromTabs();
+  suppressNextObserverRecovery(suppressedContinuations);
   void runObserverRecovery();
 }
 chrome.action.onClicked.addListener(() => {
   void openTaskPage();
 });
 chrome.runtime.onInstalled.addListener(() => {
-  void bootstrapManagedRuntimeConfig().then(async () => {
+  void restoreTransientPermissionAttempts().then(async () => {
+    await bootstrapManagedRuntimeConfig();
     await persistSnapshot();
     void runBridgeLoop();
+    const suppressedContinuations = await rebuildCarrierAttentionsFromTabs();
+    suppressNextObserverRecovery(suppressedContinuations);
     void runObserverRecovery();
   });
 });
 chrome.runtime.onStartup.addListener(() => {
   sessions.clear();
-  void bootstrapManagedRuntimeConfig().then(async () => {
+  void restoreTransientPermissionAttempts().then(async () => {
+    await bootstrapManagedRuntimeConfig();
     await persistSnapshot();
     void runBridgeLoop();
+    const suppressedContinuations = await rebuildCarrierAttentionsFromTabs();
+    suppressNextObserverRecovery(suppressedContinuations);
     void runObserverRecovery();
   });
 });