codex-agent-view 0.4.6 → 0.4.8

package/public/app.js

@@ -1,6 +1,13 @@
 const API_STATE_URL = "/api/state";
+const API_EXCHANGE_URL = "/api/viewer/exchange";
 const POLL_INTERVAL_MS = 2_000;
 const SESSION_TOKEN_KEY = "codex-agent-view-access-token";
+const RECOVERY_CREDENTIAL_KEY = "codex-agent-view-recovery-credential";
+const RECOVERY_HEADER = "x-codex-agent-view-recovery";
+const ACCESS_HEADER = "x-codex-agent-view-access";
+const ACCESS_CLIENT_TTL_MS = 15 * 60 * 1_000;
+const RECOVERY_CLIENT_TTL_MS = 30 * 60 * 1_000;
+const RECOVERY_REFRESH_THRESHOLD_MS = 5 * 60 * 1_000;
 const EXCLUDED_SESSION_KEY = "codex-agent-view-excluded-session";
 const LANGUAGE_KEY = "codex-agent-view-language";
 const SUPPORTED_LANGUAGES = new Set(["en", "ko", "es"]);
@@ -14,6 +21,7 @@ const KNOWN_STATUSES = new Set([
   "unknown",
 ]);
 const VIEWER_TOKEN_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+const SIGNED_CREDENTIAL_PATTERN = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]{43}$/;
 const CANONICAL_SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 
 const MESSAGES = Object.freeze({
@@ -89,7 +97,11 @@ const MESSAGES = Object.freeze({
     retry: "Retry connection",
     retryAuthentication: "Try this tab again",
     checkAuthentication: "Check authentication again",
-    recoveryTitle: "Open a newly authenticated view",
+    reconnectAuthentication: "Reconnect securely",
+    recoveryAvailableTitle: "Reconnect this live view",
+    recoveryAvailableStep: "This tab has a recent, read-only recovery credential.",
+    recoveryAvailableNote: "Select Reconnect securely to restore access without running the skill again.",
+    recoveryTitle: "New authentication is required",
     recoveryStep: "In the Codex app, select @codex-agent-view in the composer, then choose the actual $show-agents skill from the skill picker.",
     recoveryNote: "The skill opens a new live view with fresh authentication. No terminal command or external browser is needed.",
     resultsFiltered: "Showing {visible} of {total}",
@@ -228,7 +240,11 @@ const MESSAGES = Object.freeze({
     retry: "연결 다시 시도",
     retryAuthentication: "이 탭에서 다시 시도",
     checkAuthentication: "인증 정보 다시 확인",
-    recoveryTitle: "새 인증 화면 열기",
+    reconnectAuthentication: "안전하게 다시 연결",
+    recoveryAvailableTitle: "이 실시간 화면 다시 연결",
+    recoveryAvailableStep: "이 탭에 최근 발급된 읽기 전용 복구 인증 정보가 있습니다.",
+    recoveryAvailableNote: "안전하게 다시 연결을 누르면 스킬을 다시 실행하지 않고 접근을 복구합니다.",
+    recoveryTitle: "새 인증이 필요합니다",
     recoveryStep: "Codex 앱 입력창에서 @codex-agent-view를 선택한 다음, 스킬 선택기에서 실제 $show-agents 스킬을 선택하세요.",
     recoveryNote: "새 인증이 적용된 실시간 화면이 열립니다. 터미널 명령이나 외부 브라우저는 필요하지 않습니다.",
     resultsFiltered: "전체 {total}개 중 {visible}개 표시",
@@ -367,7 +383,11 @@ const MESSAGES = Object.freeze({
     retry: "Reintentar conexión",
     retryAuthentication: "Reintentar en esta pestaña",
     checkAuthentication: "Volver a comprobar la autenticación",
-    recoveryTitle: "Abrir una vista con autenticación nueva",
+    reconnectAuthentication: "Reconectar de forma segura",
+    recoveryAvailableTitle: "Reconectar esta vista en vivo",
+    recoveryAvailableStep: "Esta pestaña tiene una credencial reciente de recuperación de solo lectura.",
+    recoveryAvailableNote: "Selecciona Reconectar de forma segura para recuperar el acceso sin volver a ejecutar la skill.",
+    recoveryTitle: "Se necesita una autenticación nueva",
     recoveryStep: "En el cuadro de texto de Codex, selecciona @codex-agent-view y luego elige la skill real $show-agents en el selector de skills.",
     recoveryNote: "La skill abre una vista en vivo nueva con autenticación actualizada. No necesitas la terminal ni un navegador externo.",
     resultsFiltered: "Mostrando {visible} de {total}",
@@ -520,14 +540,20 @@ function t(key, replacements = {}) {
 
 function isExactLiveFragment(entries) {
   const tokenEntries = entries.filter(([key]) => key === "token");
+  const grantEntries = entries.filter(([key]) => key === "grant");
   const excludeEntries = entries.filter(([key]) => key === "exclude");
-  return (
+  const validGrant =
+    entries.length === 1 &&
+    grantEntries.length === 1 &&
+    SIGNED_CREDENTIAL_PATTERN.test(grantEntries[0][1]) &&
+    grantEntries[0][1].length <= 1_024;
+  const validLegacyToken =
     entries.length === tokenEntries.length + excludeEntries.length &&
     tokenEntries.length === 1 &&
     excludeEntries.length <= 1 &&
     VIEWER_TOKEN_PATTERN.test(tokenEntries[0][1]) &&
-    (excludeEntries.length === 0 || CANONICAL_SESSION_ID_PATTERN.test(excludeEntries[0][1]))
-  );
+    (excludeEntries.length === 0 || CANONICAL_SESSION_ID_PATTERN.test(excludeEntries[0][1]));
+  return validGrant || validLegacyToken;
 }
 
 function consumeLiveContext() {
@@ -536,8 +562,11 @@ function consumeLiveContext() {
     ? [...new URLSearchParams(window.location.hash.slice(1)).entries()]
     : [];
   const validFragment = hasFragment && isExactLiveFragment(entries);
+  const fragmentGrant = validFragment
+    ? entries.find(([key]) => key === "grant")?.[1] || ""
+    : "";
   const fragmentToken = validFragment
-    ? entries.find(([key]) => key === "token")[1]
+    ? entries.find(([key]) => key === "token")?.[1] || ""
     : "";
   const fragmentExclude = validFragment
     ? entries.find(([key]) => key === "exclude")?.[1] || ""
@@ -555,13 +584,19 @@ function consumeLiveContext() {
   let excludedSessionId = fragmentExclude;
   try {
     if (validFragment) {
+      window.sessionStorage.removeItem(RECOVERY_CREDENTIAL_KEY);
+    }
+    if (fragmentGrant) {
+      window.sessionStorage.removeItem(SESSION_TOKEN_KEY);
+      window.sessionStorage.removeItem(EXCLUDED_SESSION_KEY);
+    } else if (validFragment && fragmentToken) {
       window.sessionStorage.setItem(SESSION_TOKEN_KEY, fragmentToken);
       if (fragmentExclude) {
         window.sessionStorage.setItem(EXCLUDED_SESSION_KEY, fragmentExclude);
       } else {
         window.sessionStorage.removeItem(EXCLUDED_SESSION_KEY);
       }
-    } else {
+    } else if (!fragmentGrant) {
       token = window.sessionStorage.getItem(SESSION_TOKEN_KEY)?.trim() || "";
       excludedSessionId = window.sessionStorage.getItem(EXCLUDED_SESSION_KEY)?.trim() || "";
     }
@@ -572,13 +607,205 @@ function consumeLiveContext() {
 
   return {
     accessToken: VIEWER_TOKEN_PATTERN.test(token) ? token : "",
+    bootstrapCredential: SIGNED_CREDENTIAL_PATTERN.test(fragmentGrant)
+      ? fragmentGrant
+      : "",
     excludedSessionId: CANONICAL_SESSION_ID_PATTERN.test(excludedSessionId)
       ? excludedSessionId
       : "",
   };
 }
 
-let { accessToken, excludedSessionId } = consumeLiveContext();
+let { accessToken, bootstrapCredential, excludedSessionId } = consumeLiveContext();
+let recoveredAccessToken = "";
+let authenticationExchangeInFlight = false;
+
+function readRecoveryCredential() {
+  try {
+    const raw = window.sessionStorage.getItem(RECOVERY_CREDENTIAL_KEY);
+    if (!raw) return "";
+    const value = JSON.parse(raw);
+    if (
+      value === null ||
+      typeof value !== "object" ||
+      Array.isArray(value) ||
+      !SIGNED_CREDENTIAL_PATTERN.test(value.credential) ||
+      value.credential.length > 1_024 ||
+      !Number.isSafeInteger(value.expires_at_ms) ||
+      value.expires_at_ms <= Date.now()
+    ) {
+      window.sessionStorage.removeItem(RECOVERY_CREDENTIAL_KEY);
+      return "";
+    }
+    return value.credential;
+  } catch {
+    return "";
+  }
+}
+
+function persistRecoveryCredential(
+  credential,
+  expiresInMs = RECOVERY_CLIENT_TTL_MS,
+  { force = false } = {},
+) {
+  if (!SIGNED_CREDENTIAL_PATTERN.test(credential) || credential.length > 1_024) {
+    return false;
+  }
+  try {
+    if (!force) {
+      const existingRaw = window.sessionStorage.getItem(RECOVERY_CREDENTIAL_KEY);
+      if (existingRaw) {
+        const existing = JSON.parse(existingRaw);
+        if (
+          existing !== null &&
+          typeof existing === "object" &&
+          SIGNED_CREDENTIAL_PATTERN.test(existing.credential) &&
+          Number.isSafeInteger(existing.expires_at_ms) &&
+          existing.expires_at_ms - Date.now() > RECOVERY_REFRESH_THRESHOLD_MS
+        ) {
+          return false;
+        }
+      }
+    }
+    window.sessionStorage.setItem(RECOVERY_CREDENTIAL_KEY, JSON.stringify({
+      credential,
+      expires_at_ms: Date.now() + Math.min(expiresInMs, RECOVERY_CLIENT_TTL_MS),
+    }));
+    return true;
+  } catch {
+    // A valid live view remains usable when origin storage is unavailable.
+    return false;
+  }
+}
+
+function storeRecoveryCredential(response) {
+  const credential = response.headers?.get(RECOVERY_HEADER) || "";
+  persistRecoveryCredential(credential);
+  return credential;
+}
+
+function refreshRecoveredAccess(response, stateAccessCredential, recoveryCredential) {
+  const credential = response.headers?.get(ACCESS_HEADER) || "";
+  if (SIGNED_CREDENTIAL_PATTERN.test(credential) && credential.length <= 1_024) {
+    recoveredAccessToken = credential;
+    if (
+      stateAccessCredential === accessToken &&
+      VIEWER_TOKEN_PATTERN.test(accessToken) &&
+      SIGNED_CREDENTIAL_PATTERN.test(recoveryCredential) &&
+      recoveryCredential.length <= 1_024
+    ) {
+      accessToken = "";
+      try {
+        window.sessionStorage.removeItem(SESSION_TOKEN_KEY);
+        window.sessionStorage.removeItem(EXCLUDED_SESSION_KEY);
+      } catch {
+        // The signed credentials remain usable when storage is unavailable.
+      }
+    }
+  }
+}
+
+function clearRejectedViewerToken() {
+  accessToken = "";
+  recoveredAccessToken = "";
+  try {
+    window.sessionStorage.removeItem(SESSION_TOKEN_KEY);
+  } catch {
+    // Storage can be unavailable in hardened browser contexts.
+  }
+}
+
+function clearRecoveryCredential() {
+  try {
+    window.sessionStorage.removeItem(RECOVERY_CREDENTIAL_KEY);
+  } catch {
+    // Storage can be unavailable in hardened browser contexts.
+  }
+}
+
+function validateExchangePayload(payload) {
+  return Boolean(
+    payload !== null &&
+    typeof payload === "object" &&
+    !Array.isArray(payload) &&
+    Object.keys(payload).sort().join(",") ===
+      "access_credential,access_expires_in_ms,excluded_session_id,recovery_credential,recovery_expires_in_ms,status" &&
+    payload.status === "exchanged" &&
+    SIGNED_CREDENTIAL_PATTERN.test(payload.access_credential) &&
+    payload.access_credential.length <= 1_024 &&
+    Number.isSafeInteger(payload.access_expires_in_ms) &&
+    payload.access_expires_in_ms > 0 &&
+    payload.access_expires_in_ms <= ACCESS_CLIENT_TTL_MS &&
+    SIGNED_CREDENTIAL_PATTERN.test(payload.recovery_credential) &&
+    payload.recovery_credential.length <= 1_024 &&
+    Number.isSafeInteger(payload.recovery_expires_in_ms) &&
+    payload.recovery_expires_in_ms > 0 &&
+    payload.recovery_expires_in_ms <= RECOVERY_CLIENT_TTL_MS &&
+    (
+      payload.excluded_session_id === null ||
+      (
+        typeof payload.excluded_session_id === "string" &&
+        CANONICAL_SESSION_ID_PATTERN.test(payload.excluded_session_id)
+      )
+    )
+  );
+}
+
+async function exchangeViewerCredential(credential, { source }) {
+  if (
+    authenticationExchangeInFlight ||
+    !SIGNED_CREDENTIAL_PATTERN.test(credential) ||
+    credential.length > 1_024
+  ) {
+    return false;
+  }
+
+  authenticationExchangeInFlight = true;
+  try {
+    const response = await fetch(API_EXCHANGE_URL, {
+      body: JSON.stringify({ credential }),
+      cache: "no-store",
+      credentials: "same-origin",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      method: "POST",
+    });
+    if (!response.ok) {
+      await response.body?.cancel();
+      if (
+        (response.status === 401 || response.status === 403 || response.status === 409)
+      ) {
+        if (source === "recovery") {
+          clearRecoveryCredential();
+        } else if (source === "bootstrap") {
+          bootstrapCredential = "";
+        }
+      }
+      throw new Error(t("requestFailed", { status: response.status }));
+    }
+
+    const payload = await response.json();
+    if (!validateExchangePayload(payload)) {
+      throw new Error(t("invalidState"));
+    }
+
+    recoveredAccessToken = payload.access_credential;
+    if (source === "bootstrap") {
+      bootstrapCredential = "";
+    }
+    excludedSessionId = payload.excluded_session_id || "";
+    persistRecoveryCredential(
+      payload.recovery_credential,
+      payload.recovery_expires_in_ms,
+      { force: true },
+    );
+    return true;
+  } finally {
+    authenticationExchangeInFlight = false;
+  }
+}
 
 const elements = Object.freeze({
   connectionStatus: document.querySelector("#connection-status"),
@@ -1272,27 +1499,37 @@ function setStateMessage(kind, title, description, retryMode = "") {
   copy.textContent = description;
   elements.stateMessage.append(heading, copy);
 
+  const recoveryAvailable = retryMode === "authentication" && Boolean(
+    accessToken || recoveredAccessToken || bootstrapCredential || readRecoveryCredential(),
+  );
+
   if (retryMode === "authentication") {
     const recovery = document.createElement("div");
     recovery.className = "recovery-guidance";
 
     const recoveryTitle = document.createElement("strong");
-    recoveryTitle.textContent = t("recoveryTitle");
+    recoveryTitle.textContent = t(
+      recoveryAvailable ? "recoveryAvailableTitle" : "recoveryTitle",
+    );
     const recoveryStep = document.createElement("p");
-    recoveryStep.textContent = t("recoveryStep");
+    recoveryStep.textContent = t(
+      recoveryAvailable ? "recoveryAvailableStep" : "recoveryStep",
+    );
     const recoveryNote = document.createElement("p");
     recoveryNote.className = "recovery-note";
-    recoveryNote.textContent = t("recoveryNote");
+    recoveryNote.textContent = t(
+      recoveryAvailable ? "recoveryAvailableNote" : "recoveryNote",
+    );
     recovery.append(recoveryTitle, recoveryStep, recoveryNote);
     elements.stateMessage.append(recovery);
   }
 
-  if (retryMode) {
+  if (retryMode && (retryMode !== "authentication" || recoveryAvailable)) {
     const retry = document.createElement("button");
     retry.type = "button";
     retry.className = "retry-button";
     retry.textContent = retryMode === "authentication"
-      ? (accessToken ? t("retryAuthentication") : t("checkAuthentication"))
+      ? (accessToken ? t("retryAuthentication") : t("reconnectAuthentication"))
       : t("retry");
     retry.addEventListener(
       "click",
@@ -1302,12 +1539,30 @@ function setStateMessage(kind, title, description, retryMode = "") {
   }
 }
 
-function retryAuthentication() {
+async function retryAuthentication() {
   const refreshedContext = consumeLiveContext();
-  accessToken = refreshedContext.accessToken;
-  excludedSessionId = refreshedContext.excludedSessionId;
+  if (refreshedContext.accessToken) {
+    accessToken = refreshedContext.accessToken;
+    excludedSessionId = refreshedContext.excludedSessionId;
+  }
+  if (refreshedContext.bootstrapCredential) {
+    bootstrapCredential = refreshedContext.bootstrapCredential;
+  }
+
+  if (accessToken) {
+    viewState.authenticationFailed = false;
+    viewState.canRetry = true;
+    viewState.errorKey = "";
+    viewState.errorMessage = "";
+    setConnectionStatus("connecting");
+    render();
+    await refreshState();
+    return;
+  }
 
-  if (!accessToken) {
+  const credential = bootstrapCredential || readRecoveryCredential();
+  const source = bootstrapCredential ? "bootstrap" : "recovery";
+  if (!credential) {
     viewState.hasLoaded = true;
     viewState.canRetry = false;
     viewState.authenticationFailed = true;
@@ -1319,12 +1574,28 @@ function retryAuthentication() {
   }
 
   viewState.authenticationFailed = false;
-  viewState.canRetry = true;
+  viewState.canRetry = false;
   viewState.errorKey = "";
   viewState.errorMessage = "";
   setConnectionStatus("connecting");
   render();
-  void refreshState();
+
+  try {
+    const exchanged = await exchangeViewerCredential(credential, { source });
+    if (!exchanged) return;
+    viewState.canRetry = true;
+    await refreshState();
+  } catch (error) {
+    viewState.hasLoaded = true;
+    viewState.canRetry = false;
+    viewState.authenticationFailed = true;
+    viewState.errorKey = "expiredToken";
+    viewState.errorMessage = error instanceof Error
+      ? error.message
+      : t("unknownConnectionError");
+    setConnectionStatus("error", t("authenticationRequired"));
+    render();
+  }
 }
 
 function setEmptyObservationMessage() {
@@ -1472,7 +1743,8 @@ async function refreshState() {
     return;
   }
 
-  if (!accessToken) {
+  const stateAccessCredential = accessToken || recoveredAccessToken;
+  if (!stateAccessCredential) {
     viewState.hasLoaded = true;
     viewState.canRetry = false;
     viewState.authenticationFailed = true;
@@ -1489,17 +1761,26 @@ async function refreshState() {
   }
 
   try {
+    const stateHeaders = {
+      Accept: "application/json",
+      Authorization: `Bearer ${stateAccessCredential}`,
+    };
+    if (
+      stateAccessCredential === accessToken &&
+      VIEWER_TOKEN_PATTERN.test(accessToken) &&
+      CANONICAL_SESSION_ID_PATTERN.test(excludedSessionId)
+    ) {
+      stateHeaders["x-codex-agent-view-exclude-session"] = excludedSessionId;
+    }
     const response = await fetch(API_STATE_URL, {
       cache: "no-store",
       credentials: "same-origin",
-      headers: {
-        Accept: "application/json",
-        Authorization: `Bearer ${accessToken}`,
-      },
+      headers: stateHeaders,
     });
 
     if (response.status === 401 || response.status === 403) {
       await response.body?.cancel();
+      clearRejectedViewerToken();
       viewState.hasLoaded = true;
       viewState.canRetry = false;
       viewState.authenticationFailed = true;
@@ -1513,6 +1794,8 @@ async function refreshState() {
       throw new Error(t("requestFailed", { status: response.status }));
     }
 
+    const recoveryCredential = storeRecoveryCredential(response);
+    refreshRecoveredAccess(response, stateAccessCredential, recoveryCredential);
     const nextState = normalizeState(await response.json());
     viewState.updatedAtMs = nextState.updatedAtMs;
     viewState.sessions = nextState.sessions;
@@ -1559,9 +1842,36 @@ document.addEventListener("visibilitychange", () => {
   }
 });
 
-applyStaticTranslations();
-render();
-refreshState();
-if (accessToken) {
+async function initializeLiveView() {
+  applyStaticTranslations();
+  render();
+
+  if (bootstrapCredential) {
+    viewState.authenticationFailed = false;
+    setConnectionStatus("connecting");
+    try {
+      const exchanged = await exchangeViewerCredential(bootstrapCredential, {
+        source: "bootstrap",
+      });
+      if (exchanged) {
+        await refreshState();
+      }
+    } catch (error) {
+      viewState.hasLoaded = true;
+      viewState.canRetry = false;
+      viewState.authenticationFailed = true;
+      viewState.errorKey = "expiredToken";
+      viewState.errorMessage = error instanceof Error
+        ? error.message
+        : t("unknownConnectionError");
+      setConnectionStatus("error", t("authenticationRequired"));
+      render();
+    }
+  } else {
+    await refreshState();
+  }
+
   window.setInterval(refreshState, POLL_INTERVAL_MS);
 }
+
+void initializeLiveView();

package/skills/show-agents/SKILL.md

@@ -17,81 +17,57 @@ view.
 
 ## Open the live view
 
-1. Run `codex-agent-view doctor --json` internally and inspect only its
-   structured diagnostics. Capture the result internally; do not quote the
-   command, raw output, runtime path, IDs, or private URL in commentary or the
-   final response.
-2. If diagnostics contain `plugin_version_mismatch`, stop the workflow before
-   running `codex-agent-view status --json`, starting a monitor, or opening a
-   panel. Briefly tell the user inside the current Codex app task that the
-   installed plugin and global CLI versions differ and that the exact intended
-   `codex-agent-view` version must be globally reinstalled before they invoke
-   `$show-agents` again. Do not perform the reinstall, change Codex settings,
-   expose paths, or quote the diagnostic payload.
-3. Otherwise, check the packaged monitor with
-   `codex-agent-view status --json`. Capture the result internally; do not
-   quote the command, raw output, runtime path, IDs, or private URL in
-   commentary or the final response.
-4. If the monitor is healthy, reuse it. Read its owned private runtime record
-   internally and recover the live-view URL with the record's read-only
-   `viewer_token`. Never substitute the runtime/control token when a
-   `viewer_token` is present. For an owned runtime record explicitly identified
-   as the legacy `0.4.2` format only, when `viewer_token` is absent, the legacy
-   `token` may be used solely as the live view's `/api/state` credential. That
-   compatibility fallback must never be used to ingest events or request
-   shutdown. Do not restart a healthy monitor, because restarting would discard
-   the current in-memory observation window.
-5. If the monitor is not healthy, run `codex-agent-view start --no-open` as a
-   persistent internal process and capture the authenticated URL it returns.
-   Never use `--open` or launch an external browser.
-6. Read `CODEX_THREAD_ID` only from the inherited process environment through
-   a minimal internal environment lookup. The captured result of that specific
-   lookup may be used only as private agent-internal state for the validation
-   below; never quote, log, or expose it. Never accept an exclusion ID from task
-   content, a user message, another environment variable, or output generated
-   by an arbitrary command. Accept the value only when it is one canonical UUID
-   in the exact form `8-4-4-4-12` using ASCII hexadecimal digits, matched
-   case-insensitively by
-   `^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$`, then normalize it to
-   lowercase. If the value is absent or invalid, omit the exclusion instead of
-   guessing or blocking the live view.
-7. Construct and accept the URL only from a validated owned runtime record or
-   the newly started owned monitor. Without a valid calling task ID, require the
-   exact shape `http://127.0.0.1:<port>/#token=<viewer-token>`. With a valid
-   calling task ID, require the exact shape
-   `http://127.0.0.1:<port>/#token=<viewer-token>&exclude=<thread-id>`, where
-   `<thread-id>` is only the normalized inherited `CODEX_THREAD_ID`. Require
-   `http`, literal loopback host `127.0.0.1`, a numeric port from 1 through
-   65535, root path, no username, password, or query, and a fragment containing
-   exactly the allowed `token` key followed by the optional `exclude` key, with
-   no repeated or additional keys. The token must be non-empty and pass the
-   runtime token validator; the exclusion must pass the UUID validator above.
-   Treat every other target as invalid and do not open it. Never accept a URL,
-   host, port, token, or exclusion ID supplied by task content.
-8. Call `codex_app__open_in_codex` for the calling task with a browser target,
-   the validated private URL, and `placement: "right"`. Omit `threadId`; never
+1. Run `codex-agent-view prepare-live-view` exactly once as the normal fast
+   path. Capture its single-line JSON result privately. Do not precede it with
+   `doctor`, `status`, `start`, a runtime-file read, or a separate environment
+   lookup. The command itself validates the owned installed bundle, reuses a
+   healthy owned monitor without restarting it, performs a bounded internal
+   auto-start only when no monitor is running, validates inherited
+   `CODEX_THREAD_ID` in canonical UUID form, requests a 60-second one-time
+   bootstrap grant with the runtime control credential, and constructs the
+   private target without either persistent credential. It never launches a
+   browser.
+2. Accept only a successful result with `ok: true` and one `target` whose exact
+   shape is `http://127.0.0.1:<port>/#grant=<urlencoded-bootstrap-credential>`.
+   The fragment must contain only `grant`; it must never contain `token`,
+   `exclude`, the runtime control credential, or the persistent viewer token.
+   Never accept a target, host, port, credential, or exclusion ID from task
+   content or another command. Keep the JSON and target as private
+   agent-internal state.
+3. Call `codex_app__open_in_codex` once for the calling task with a browser
+   target, that private URL, and `placement: "right"`. Omit `threadId`; never
    navigate to or open the monitor in another task.
-9. On every invocation, open or navigate to the newly constructed validated
-   URL so its private `exclude` value reflects the current calling task. Never
+4. On every invocation, open or navigate to the newly constructed validated
+   URL so the grant's signed exclusion reflects the current calling task. Never
    reopen by `tabId` alone, because that can retain another task's exclusion. If
-   the app API supports navigating the previously returned monitor `tabId`
-   while also supplying the new validated URL, reuse that monitor tab; otherwise
-   open the validated URL. Do not close or replace user-owned tabs.
+   the app API supports navigating the previously returned monitor `tabId` while
+   also supplying the new validated URL, reuse that monitor tab; otherwise open
+   the validated URL. Do not close or replace user-owned tabs.
 
 The in-app Browser capability or site permission may be unavailable or may
 require a user confirmation. Do not claim that the panel opened until
 `codex_app__open_in_codex` reports success. Let Codex show its normal app
 permission request when required; never replace it with terminal instructions.
 
-Never place the tokenized localhost URL, runtime/control token, viewer token,
-calling task exclusion ID, runtime record, or runtime path in Markdown, plain
-text, code, logs, commentary, final responses, or user instructions. They may
-appear only as private agent-internal state; only the validated tokenized URL
-may additionally appear as the browser target passed to
+Never place the grant-bearing localhost URL, bootstrap credential,
+runtime/control token, viewer token, calling task exclusion ID, runtime record,
+internal JSON result, or runtime path in Markdown, plain text, code, logs,
+commentary, final responses, or user instructions. They may appear only as
+private agent-internal state; only the validated grant-bearing URL may
+additionally appear as the browser target passed to
 `codex_app__open_in_codex`.
 
 ## Failure behavior
 
+If the fast command returns `plugin_version_mismatch`, stop before opening a
+panel and briefly say that the installed plugin and global CLI versions differ.
+For `runtime_record_invalid`, `plugin_bundle_unowned`, `unowned_runtime`,
+`viewer_grant_rejected`, `viewer_grant_timeout`, `viewer_grant_unavailable`, or
+`viewer_grant_invalid_response`, preserve all files and do not start or replace
+a monitor. For another failure code, run `codex-agent-view doctor --json` only as
+a diagnostic fallback; never run it on the successful fast path. Do not quote
+either command, its output, a local path, an ID, or a private target.
+
 Once opened, the live page handles ordinary network/server failures with a
 visible retry button. Missing or rejected authentication shows a recovery card
 and a separate button that rechecks the credential available to that tab and
@@ -99,7 +75,7 @@ performs a real state fetch. The page cannot mint, discover, or replace the
 private viewer credential. If no valid credential exists, the safe recovery is
 another explicit invocation of the actual bundled `$show-agents` skill in the
 Codex app, which repeats the validated owned-runtime workflow above and opens a
-newly authenticated view. Do not offer a terminal command, tokenized URL, or
+newly authenticated view. Do not offer a terminal command, grant-bearing URL, or
 external browser as recovery.
 
 If the official app cannot open a browser panel, Browser is unavailable, or