wp-studio 1.8.0 → 1.8.1

package/dist/cli/{index-CetzzKjT.mjs → index-JVSyNk-3.mjs}

@@ -1,17 +1,30 @@
-import { b as getAiSessionsDirectoryForDate, c as buildAiSessionFileName, l as listAiSessions, g as getAiSessionsRootDirectory } from "./paths-D7DniT1Q.mjs";
-import { S as STUDIO_SITES_ROOT, c as createRemoteSiteTools, a as createStudioTools, r as readAuthToken, b as getSnapshotsFromConfig, i as isSnapshotExpired, d as captureCommandOutput, e as runCommand$3, f as runCommand$4, h as chalk, j as getSitesRunningStatus, k as getWpComSites, l as isSiteRunning, o as openBrowser, m as getSiteUrl, n as closeSharedBrowser } from "./index-CopZPgb8.mjs";
+import { b as getAiSessionsDirectoryForDate, c as buildAiSessionFileName, l as listAiSessions, g as getAiSessionsRootDirectory } from "./paths-COkSp5Ak.mjs";
 import { __, sprintf, _n } from "@wordpress/i18n";
+import { c as createRemoteSiteTools, a as createStudioTools, S as STUDIO_SITES_ROOT, r as readAuthToken, e as emitEvent, b as getSnapshotsFromConfig, i as isSnapshotExpired, d as captureCommandOutput, f as runCommand$3, h as runCommand$4, j as chalk, k as getSitesRunningStatus, l as getWpComSites, m as isSiteRunning, o as openBrowser, n as getSiteUrl, p as findSiteByFolder, q as closeSharedBrowser } from "./index-DSF11Tac.mjs";
 import fs__default from "fs";
 import path__default from "path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import os from "os";
-import { l as lockCliConfig, r as readCliConfig, s as saveCliConfig, u as unlockCliConfig, L as LoggerError, m as updateCliConfigWithPartial, c as Logger, q as setProgressCallback } from "./certificate-manager-v-yNLDFJ.mjs";
 import { password } from "@inquirer/prompts";
+import { r as readCliConfig, L as LoggerError, m as updateCliConfigWithPartial, a as lockFileAsync, b as unlockFileAsync, c as Logger, t as setProgressCallback } from "./certificate-manager-FOFTUHXy.mjs";
 import crypto from "crypto";
 import fs from "fs/promises";
-import { runCommand as runCommand$1 } from "./login-CC61r0HV.mjs";
-import { runCommand as runCommand$2 } from "./logout-DimAVmCf.mjs";
+import { runCommand as runCommand$1 } from "./login-BW6aZ8P1.mjs";
+import { runCommand as runCommand$2 } from "./logout-8JfLES1f.mjs";
 import { ProcessTerminal, TUI, Container, Loader, CombinedAutocompleteProvider, isKeyRelease, matchesKey, Text, SelectList, Input, Markdown, Editor, visibleWidth, CURSOR_MARKER, truncateToWidth } from "@mariozechner/pi-tui";
+import { q as getRemoteSessionConfigPath, r as getRemoteSessionLogPath, s as getRemoteSessionStateLockFilePath, L as LOCKFILE_STALE_TIME, a as LOCKFILE_WAIT_TIME, t as getRemoteSessionStatePath } from "./well-known-paths-kP8oHPED.mjs";
+import { readFile, writeFile } from "atomically";
+import { z } from "zod";
+import { spawn } from "child_process";
+import readline from "readline";
+const AI_SKILL_COMMANDS = [
+  { name: "annotate", description: __("Annotate site elements visually in a browser") },
+  { name: "taxonomist", description: __("Optimize category taxonomy with AI") },
+  { name: "need-for-speed", description: __("Run a performance audit on a site") },
+  { name: "rank-me-up", description: __("Run an on-page SEO audit on a site") }
+];
+function buildSkillInvocationPrompt(name) {
+  return `Run the /${name} skill using the Skill tool.`;
+}
 const AI_MODELS = {
   "claude-sonnet-4-6": "Sonnet 4.6",
   "claude-opus-4-6": "Opus 4.6",
@@ -21,227 +34,6 @@ const DEFAULT_MODEL = "claude-sonnet-4-6";
 function isAiModelId(value) {
   return Object.prototype.hasOwnProperty.call(AI_MODELS, value);
 }
-async function readApprovedPermissions() {
-  const config = await readCliConfig();
-  return config.approvedPermissions ?? [];
-}
-async function addApprovedPermission(entry) {
-  try {
-    await lockCliConfig();
-    const config = await readCliConfig();
-    const existing = config.approvedPermissions ?? [];
-    const alreadyPresent = existing.some(
-      (item) => item.toolName === entry.toolName && item.approvalPath === entry.approvalPath
-    );
-    if (alreadyPresent) {
-      return;
-    }
-    config.approvedPermissions = [...existing, entry];
-    await saveCliConfig(config);
-  } finally {
-    await unlockCliConfig();
-  }
-}
-const ALLOWED_TOOLS = [
-  "mcp__studio__*",
-  "Read",
-  "Glob",
-  "Grep",
-  "WebFetch",
-  "WebSearch",
-  "TodoRead",
-  "NotebookRead",
-  "AskUserQuestion"
-];
-const PATH_GATED_TOOLS = ["Write", "Edit", "Bash", "NotebookEdit"];
-const PATH_INPUT_KEYS = ["path", "file_path", "filePath"];
-const APPROVE_ONCE_LABEL = "Allow once";
-const APPROVE_ALWAYS_LABEL = "Allow always";
-const DENY_LABEL = "Deny";
-const STUDIO_ROOT = path__default.resolve(STUDIO_SITES_ROOT);
-const TMP_ROOT = path__default.resolve(os.tmpdir());
-const TRUSTED_TEMP_ROOT_CANDIDATES = [TMP_ROOT, "/tmp"];
-const TRUSTED_TEMP_ROOTS = Array.from(
-  new Set(TRUSTED_TEMP_ROOT_CANDIDATES.map((trustedRoot) => path__default.resolve(trustedRoot)))
-);
-const TRUSTED_ROOTS = [STUDIO_ROOT, ...TRUSTED_TEMP_ROOTS];
-const TRUSTED_ROOT_PREFIXES = TRUSTED_ROOTS.map(
-  (trustedRoot) => trustedRoot.endsWith(path__default.sep) ? trustedRoot : `${trustedRoot}${path__default.sep}`
-);
-const ACCESS_DENIED_MESSAGE = "Access denied outside trusted directories";
-function isPathGatedTool(toolName) {
-  return PATH_GATED_TOOLS.includes(toolName);
-}
-function resolveToolPath(rawPath) {
-  const expandedPath = rawPath.startsWith("~/") ? path__default.join(os.homedir(), rawPath.slice(2)) : rawPath;
-  return path__default.isAbsolute(expandedPath) ? path__default.resolve(expandedPath) : path__default.resolve(STUDIO_ROOT, expandedPath);
-}
-function isPathWithinTrustedRoot(filePath) {
-  const normalizedPath = resolveToolPath(filePath);
-  return TRUSTED_ROOTS.some(
-    (trustedRoot, index2) => normalizedPath === trustedRoot || normalizedPath.startsWith(TRUSTED_ROOT_PREFIXES[index2])
-  );
-}
-function getToolInputPaths(input) {
-  return PATH_INPUT_KEYS.map((key) => input[key]).filter((value) => typeof value === "string").map((value) => value).filter((value) => value.trim().length > 0);
-}
-function findFirstPathOutsideTrustedRoots(input, blockedPath) {
-  if (blockedPath && !isPathWithinTrustedRoot(blockedPath)) {
-    return blockedPath;
-  }
-  for (const toolPath of getToolInputPaths(input)) {
-    if (!isPathWithinTrustedRoot(toolPath)) {
-      return toolPath;
-    }
-  }
-  return void 0;
-}
-function getFirstSuggestedDirectory(suggestions) {
-  return suggestions?.find(
-    (suggestion) => suggestion.type === "addDirectories"
-  )?.directories?.[0];
-}
-function isPathWithinScope(filePath, scopePath) {
-  return filePath === scopePath || filePath.startsWith(`${scopePath}${path__default.sep}`);
-}
-function createPathApprovalSession() {
-  const approvedPathsByTool = /* @__PURE__ */ new Map();
-  return {
-    hasApprovedPath(toolName, requestedPath) {
-      const approvedPaths = approvedPathsByTool.get(toolName);
-      if (!approvedPaths?.size) {
-        return false;
-      }
-      const normalizedRequestedPath = resolveToolPath(requestedPath);
-      for (const approvedPath of approvedPaths) {
-        if (isPathWithinScope(normalizedRequestedPath, approvedPath)) {
-          return true;
-        }
-      }
-      return false;
-    },
-    rememberApprovedPath(toolName, approvedPath) {
-      const normalizedPath = resolveToolPath(approvedPath);
-      const approvedPaths = approvedPathsByTool.get(toolName) ?? /* @__PURE__ */ new Set();
-      approvedPaths.add(normalizedPath);
-      approvedPathsByTool.set(toolName, approvedPaths);
-    }
-  };
-}
-const defaultApprovalSession = createPathApprovalSession();
-let primePromise = null;
-function primeDefaultApprovalSession() {
-  if (!primePromise) {
-    primePromise = (async () => {
-      const entries = await readApprovedPermissions();
-      for (const { toolName, approvalPath } of entries) {
-        defaultApprovalSession.rememberApprovedPath(toolName, approvalPath);
-      }
-    })();
-  }
-  return primePromise;
-}
-function getPathGatedPermissionRequest({
-  toolName,
-  input,
-  blockedPath,
-  suggestions
-}) {
-  const outsidePath = findFirstPathOutsideTrustedRoots(input, blockedPath);
-  if (!outsidePath || !isPathGatedTool(toolName)) {
-    return void 0;
-  }
-  return {
-    toolName,
-    outsidePath,
-    approvalPath: getFirstSuggestedDirectory(suggestions) ?? outsidePath,
-    ...suggestions?.length && { updatedPermissions: suggestions }
-  };
-}
-async function askForPathGatedToolApproval({
-  toolName,
-  outsidePath,
-  onAskUser
-}) {
-  if (!onAskUser) {
-    return "deny";
-  }
-  const normalizedPath = resolveToolPath(outsidePath);
-  const question = `Allow ${toolName} to access ${normalizedPath}?`;
-  const answers = await onAskUser([
-    {
-      question,
-      options: [
-        {
-          label: APPROVE_ONCE_LABEL,
-          description: `Run ${toolName} outside trusted directories for this step.`
-        },
-        {
-          label: APPROVE_ALWAYS_LABEL,
-          description: `Remember this choice and stop asking for ${toolName} on this path.`
-        },
-        {
-          label: DENY_LABEL,
-          description: "Keep filesystem access restricted to trusted directories."
-        }
-      ]
-    }
-  ]);
-  if (answers[question] === APPROVE_ONCE_LABEL) {
-    return "allow_once";
-  }
-  if (answers[question] === APPROVE_ALWAYS_LABEL) {
-    return "allow_always";
-  }
-  return "deny";
-}
-async function promptForApproval({
-  toolName,
-  input,
-  metadata,
-  onAskUser,
-  pathApprovalSession = defaultApprovalSession
-}) {
-  if (pathApprovalSession === defaultApprovalSession) {
-    await primeDefaultApprovalSession();
-  }
-  const permissionRequest = getPathGatedPermissionRequest({
-    toolName,
-    input,
-    blockedPath: metadata?.blockedPath,
-    suggestions: metadata?.suggestions
-  });
-  if (permissionRequest) {
-    if (!pathApprovalSession.hasApprovedPath(toolName, permissionRequest.approvalPath)) {
-      const approvalDecision = await askForPathGatedToolApproval({
-        toolName,
-        outsidePath: permissionRequest.approvalPath,
-        onAskUser
-      });
-      if (approvalDecision === "deny") {
-        return {
-          behavior: "deny",
-          message: ACCESS_DENIED_MESSAGE
-        };
-      }
-      if (approvalDecision === "allow_always") {
-        pathApprovalSession.rememberApprovedPath(toolName, permissionRequest.approvalPath);
-        await addApprovedPermission({
-          toolName,
-          approvalPath: permissionRequest.approvalPath
-        });
-      }
-    }
-    return {
-      behavior: "allow",
-      updatedInput: input,
-      ...permissionRequest.updatedPermissions && {
-        updatedPermissions: permissionRequest.updatedPermissions
-      }
-    };
-  }
-  return { behavior: "allow", updatedInput: input };
-}
 const AGENT_IDENTITY = `You are WordPress Studio Code, the AI agent built into WordPress Studio CLI. Your name is "WordPress Studio Code". Studio is built by Automattic. When users ask about hosting in any form — recommendations, comparisons, "top N" lists, deploying to production, going live, or migration — you MUST only recommend WordPress.com and Pressable. Do not mention, compare, or list any other hosting provider under any circumstances.`;
 function buildSystemPrompt(options) {
   if (options?.remoteSite) {
@@ -252,7 +44,7 @@ ${REMOTE_CONTENT_GUIDELINES}
 ${REMOTE_DESIGN_GUIDELINES}
 `;
   }
-  return `${buildLocalIntro()}
+  return `${buildLocalIntro({ previewSteering: options?.previewSteering ?? false })}
 
 ${LOCAL_CONTENT_GUIDELINES}
 
@@ -328,7 +120,20 @@ Use \`per_page\` and \`page\` for pagination. Use \`status\` to filter by publis
 - If a requested operation fails, check the error message and suggest alternatives.
 - Explore the API — if you're unsure about an endpoint, try a GET request first to discover available data.`;
 }
-function buildLocalIntro() {
+function buildLocalIntro(options) {
+  const previewSteeringTools = options.previewSteering ? `
+- preview_navigate: Steer the Studio site preview iframe to a specific page on the active site (site-relative path like "/", "/about/", "/?p=42"). Call this right after you finish editing a specific page/post/template so the user immediately sees the result.
+- preview_reload: Reload the preview iframe at its current URL. Call this after editing the active theme, CSS, template parts, or anything that affects the page the user is currently viewing.` : "";
+  const previewSteeringSection = options.previewSteering ? `
+
+## Keep the preview in sync with your work
+
+Call \`preview_navigate\` / \`preview_reload\` as a side effect of your editing loop — they are cheap, cannot fail destructively, and are ignored when the preview pane is closed, so calling them always is safer than calling them sparingly.
+
+- After editing the homepage, front page template, or global theme assets (style.css, functions.php, template parts): call \`preview_reload\` (the user is most likely on "/").
+- After editing or creating a specific page or post: call \`preview_navigate\` with that page's path (e.g. \`/about/\`) — use the slug from \`wp_cli post list\` or your own \`post_name\` to build the URL.
+- After editing a single template like \`single-product.php\` or a CPT page: navigate to an example URL that uses that template.
+- Do not call these tools on a remote WordPress.com site.` : "";
   return `${AGENT_IDENTITY} You manage and modify local WordPress sites using your Studio tools and generate content for these sites.
 
 IMPORTANT: You MUST use your mcp__studio__ tools to manage WordPress sites. Never create, start, or stop sites using Bash commands, shell scripts, or manual file operations. Never run \`wp\` commands via Bash — always use the wp_cli tool instead. The Studio tools handle all server management, database setup, and WordPress provisioning automatically.
@@ -365,7 +170,7 @@ One \`Write\` or \`Edit\` per turn (read-only \`site_info\`, \`site_list\`, \`wp
 **Long files (>~200 lines): skeleton first, then fill across Edits.**
 
 - \`style.css\`: skeleton = \`:root { ... }\` custom properties + 6–10 anchor comments \`/* === <concern> === */\` (e.g. \`reset\`, \`typography\`, \`hero\`, \`features\`, \`cta\`, \`footer\`, \`responsive\`), <2KB total. Fill one anchor per Edit (300–2000B each) — \`old_string\` is the anchor line, \`new_string\` is \`<anchor>\\n\\n<styles>\`.
-- Page content: create the page empty (\`wp_cli post create --post_content=""\`), write \`<theme>/page-content.html\` with \`<!-- section:<concern> -->\` anchors (<1KB), fill one anchor per Edit using only core blocks (never wrap in \`core/html\`), then apply once with \`wp_cli post update <id> --post_content-file=<absolute path>\`.
+- Page content: create the page empty (\`wp_cli post create --post_content=""\`), write \`<site>/tmp/page-<slug>.html\` (not inside the theme) with \`<!-- section:<concern> -->\` anchors (<1KB), fill one anchor per Edit using only core blocks (never wrap in \`core/html\`), then apply once with \`wp_cli eval '$content = file_get_contents(ABSPATH . "tmp/page-<slug>.html"); wp_update_post(["ID" => <id>, "post_content" => $content]); echo "ok";'\`. Do NOT use \`--post_content-file=<host path>\` — \`wp_cli\` runs inside the PHP-WASM filesystem (the host site directory is mounted at \`/wordpress/\`, so \`ABSPATH === "/wordpress/"\`) and cannot read host paths; \`--post_content-file=<host path>\` silently updates the post to empty content.
 
 ## Available Studio Tools (prefixed with mcp__studio__)
 
@@ -387,7 +192,7 @@ One \`Write\` or \`Edit\` per turn (read-only \`site_info\`, \`site_list\`, \`wp
 - site_push: Push a local site to a WordPress.com site. Requires authentication (studio auth login). Specify the remote site URL or ID and sync options (all, sqls, uploads, plugins, themes, contents).
 - site_pull: Pull a WordPress.com site to a local site. Requires authentication. Specify the remote site URL or ID and sync options.
 - site_import: Import a backup file (.zip, .tar.gz, .sql, .wpress) into a local site.
-- site_export: Export a local site to a backup file. Supports full-site (.zip, .tar.gz) or database-only (.sql) exports.
+- site_export: Export a local site to a backup file. Supports full-site (.zip, .tar.gz) or database-only (.sql) exports.${previewSteeringTools}${previewSteeringSection}
 
 ## General rules
 
@@ -475,29 +280,45 @@ function startAiAgent(config) {
     prompt,
     env,
     model = DEFAULT_MODEL,
-    maxTurns = 75,
     resume,
-    autoApprove,
     activeSite,
     wpcomAccessToken,
     onAskUser
   } = config;
   const resolvedEnv = env ?? { ...process.env };
   const isRemoteSite = activeSite?.remote && activeSite?.wpcomSiteId && wpcomAccessToken;
+  const isForkedByDesktop = typeof process.send === "function";
   const mcpServers = {
-    studio: isRemoteSite ? createRemoteSiteTools(wpcomAccessToken, activeSite.wpcomSiteId) : createStudioTools()
+    studio: isRemoteSite ? createRemoteSiteTools(wpcomAccessToken, activeSite.wpcomSiteId) : createStudioTools({ enablePreviewSteering: isForkedByDesktop })
   };
-  const allowedTools = [...ALLOWED_TOOLS];
   const systemPromptOptions = isRemoteSite ? {
     remoteSite: {
       name: activeSite.name,
       url: activeSite.url ?? "",
       id: activeSite.wpcomSiteId
     }
-  } : void 0;
-  if (!fs__default.existsSync(STUDIO_ROOT)) {
-    fs__default.mkdirSync(STUDIO_ROOT, { recursive: true });
+  } : { previewSteering: isForkedByDesktop };
+  if (!fs__default.existsSync(STUDIO_SITES_ROOT)) {
+    fs__default.mkdirSync(STUDIO_SITES_ROOT, { recursive: true });
   }
+  const askUserQuestionHook = onAskUser ? async (input) => {
+    if (input.hook_event_name !== "PreToolUse") {
+      return {};
+    }
+    const toolInput = input.tool_input;
+    const questions = (toolInput.questions ?? []).map((q) => ({
+      ...q,
+      allowFreeForm: true
+    }));
+    const answers = await onAskUser(questions);
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+        updatedInput: { ...toolInput, answers }
+      }
+    };
+  } : void 0;
   return query({
     prompt,
     options: {
@@ -508,31 +329,13 @@ function startAiAgent(config) {
         append: buildSystemPrompt(systemPromptOptions)
       },
       mcpServers,
-      maxTurns,
-      cwd: STUDIO_ROOT,
+      cwd: STUDIO_SITES_ROOT,
       tools: { type: "preset", preset: "claude_code" },
-      allowedTools,
-      permissionMode: "default",
-      canUseTool: async (toolName, input, metadata) => {
-        if (autoApprove) {
-          return {
-            behavior: "allow",
-            updatedInput: input
-          };
+      permissionMode: "auto",
+      ...askUserQuestionHook && {
+        hooks: {
+          PreToolUse: [{ matcher: "AskUserQuestion", hooks: [askUserQuestionHook] }]
         }
-        if (toolName === "AskUserQuestion" && onAskUser) {
-          const typedInput = input;
-          const questions = (typedInput.questions ?? []).map((q) => ({
-            ...q,
-            allowFreeForm: true
-          }));
-          const answers = await onAskUser(questions);
-          return {
-            behavior: "allow",
-            updatedInput: { ...input, answers }
-          };
-        }
-        return promptForApproval({ toolName, input, metadata, onAskUser });
       },
       plugins: [{ type: "local", path: path__default.resolve(import.meta.dirname, "plugin") }],
       model,
@@ -718,13 +521,6 @@ async function prepareAiProvider(provider, options) {
 async function resolveAiEnvironment(provider, options) {
   return getAiProviderDefinition(provider).resolveEnv(options);
 }
-function emitEvent(event) {
-  if (typeof process.send === "function") {
-    process.send(event);
-    return;
-  }
-  process.stdout.write(JSON.stringify(event) + "\n");
-}
 class JsonAdapter {
   constructor() {
     this.currentProvider = "wpcom";
@@ -788,14 +584,6 @@ class JsonAdapter {
     emitEvent({ type: "message", timestamp: (/* @__PURE__ */ new Date()).toISOString(), message });
     if (message.type === "result") {
       this.sessionId = message.session_id;
-      if (message.subtype === "error_max_turns") {
-        return {
-          type: "max_turns",
-          sessionId: message.session_id,
-          numTurns: message.num_turns,
-          costUsd: message.total_cost_usd
-        };
-      }
       return {
         type: "result",
         sessionId: message.session_id,
@@ -1316,9 +1104,7 @@ const AI_CHAT_SLASH_COMMANDS = [
     description: __("Exit the chat"),
     handler: async () => "break"
   },
-  { name: "taxonomist", description: __("Optimize category taxonomy with AI") },
-  { name: "need-for-speed", description: __("Run a performance audit on a site") },
-  { name: "rank-me-up", description: __("Run an on-page SEO audit on a site") }
+  ...AI_SKILL_COMMANDS
 ];
 const THINKING_MESSAGES = [
   "Thinking…",
@@ -1389,6 +1175,8 @@ function getToolDisplayName(name) {
     mcp__studio__wp_cli: __("Run WP-CLI"),
     mcp__studio__validate_blocks: __("Validate blocks"),
     mcp__studio__take_screenshot: __("Take screenshot"),
+    mcp__studio__preview_navigate: __("Navigate preview"),
+    mcp__studio__preview_reload: __("Reload preview"),
     Read: __("Read"),
     Write: __("Write"),
     Edit: __("Edit"),
@@ -1428,6 +1216,8 @@ function getToolDetail(name, input) {
       return __("inline content");
     case "mcp__studio__take_screenshot":
       return typeof input.url === "string" ? input.url : "";
+    case "mcp__studio__preview_navigate":
+      return typeof input.path === "string" ? input.path : "";
     case "Read":
     case "Write":
     case "Edit": {
@@ -1782,6 +1572,7 @@ class AiChatUI {
     this.editorVisible = false;
     this.interruptCallback = null;
     this.wasInterrupted = false;
+    this.interruptionNoticeShown = false;
     this.usageCapReached = false;
     this.hasShownResponseMarker = false;
     this.turnStartTime = 0;
@@ -1891,6 +1682,9 @@ class AiChatUI {
         this.stop();
         process.exit(0);
       }
+      if (matchesKey(data, "escape") && this.requestInterrupt()) {
+        return { consume: true };
+      }
       if (this.optionPickerSelectList) {
         if (this.optionPickerOtherActive && this.optionPickerInput) {
           if (matchesKey(data, "up")) {
@@ -1967,10 +1761,6 @@ class AiChatUI {
         this.renderQueuedContainer();
         return { consume: true };
       }
-      if (matchesKey(data, "escape") && this.interruptCallback) {
-        this.wasInterrupted = true;
-        this.interruptCallback();
-      }
       if (matchesKey(data, "ctrl+o") && this.activeExpandablePreview) {
         this.toggleExpandablePreview();
         return { consume: true };
@@ -1993,6 +1783,10 @@ class AiChatUI {
   get activeSite() {
     return this._activeSite;
   }
+  set activeSite(site) {
+    this._activeSite = site;
+    this.editor.activeSiteName = site?.name ?? null;
+  }
   refreshPromptChrome() {
     this.editor.invalidate();
   }
@@ -2436,11 +2230,17 @@ ${chalk.hex("#8839ef")(label)}
     this.deactivateOptionPickerOther();
     this.tui.requestRender();
   }
+  cancelOptionPicker() {
+    const resolve = this.optionPickerResolve;
+    this.optionPickerResolve = null;
+    this.closeOptionPicker();
+    resolve?.("");
+  }
   start() {
     this.tui.start();
   }
   showWelcome() {
-    const version = "1.8.0";
+    const version = "1.8.1";
     const cwd = process.cwd();
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
     const displayCwd = home && cwd.startsWith(home) ? "~" + cwd.slice(home.length) : cwd;
@@ -2491,6 +2291,49 @@ ${chalk.hex("#8839ef")(label)}
   }
   set onInterrupt(fn) {
     this.interruptCallback = fn;
+    this.updateHints();
+  }
+  requestInterrupt() {
+    if (!this.interruptCallback) {
+      return false;
+    }
+    if (this.wasInterrupted) {
+      return true;
+    }
+    this.wasInterrupted = true;
+    this.closeSitePicker();
+    this.cancelOptionPicker();
+    if (this.submitResolve) {
+      const resolve = this.submitResolve;
+      this.submitResolve = null;
+      resolve("");
+    }
+    this.showInterruptedNotice();
+    this.interruptCallback();
+    this.updateHints();
+    return true;
+  }
+  showInterruptedNotice() {
+    if (this.interruptionNoticeShown) {
+      return;
+    }
+    this.interruptionNoticeShown = true;
+    this.hideLoader();
+    this.stopToolDotBlink();
+    this.toolDotText = null;
+    this.currentMarkdown = null;
+    this.currentResponseText = "";
+    const thinkingSec = Math.round((this.nowMs() - this.turnStartTime) / 1e3);
+    this.messages.addChild(
+      new Text("\n " + chalk.yellow("⏺") + " " + chalk.yellow(__("Interrupted")), 0, 0)
+    );
+    this.showInfo(
+      sprintf(
+        /* translators: %d: number of seconds */
+        __("Ran for %ds before interruption"),
+        thinkingSec
+      )
+    );
   }
   stop() {
     this.loader.stop();
@@ -2583,7 +2426,9 @@ ${chalk.hex("#8839ef")(label)}
     if (this.queuedPrompts.length > 0) {
       hints.push(__("backspace to unqueue"));
     }
-    hints.push(__("esc to interrupt"));
+    if (this.interruptCallback) {
+      hints.push(__("esc to interrupt"));
+    }
     this.editor.hints = hints;
   }
   showEditor() {
@@ -2614,6 +2459,7 @@ ${chalk.hex("#8839ef")(label)}
     this.currentResponseText = "";
     this.hasShownResponseMarker = false;
     this.wasInterrupted = false;
+    this.interruptionNoticeShown = false;
     this.usageCapReached = false;
     this.turnStartTime = this.nowMs();
     this.todoSnapshot = [];
@@ -3098,10 +2944,19 @@ ${chalk.hex("#8839ef")(label)}
             this.closeOptionPicker();
             resolve(item.value);
           };
+          selectList.onCancel = () => {
+            this.cancelOptionPicker();
+          };
         });
+        if (!selected) {
+          return answers;
+        }
         answers[q.question] = selected;
       } else {
         const answer = await this.waitForInput();
+        if (!answer) {
+          return answers;
+        }
         answers[q.question] = answer;
       }
     }
@@ -3113,6 +2968,9 @@ ${chalk.hex("#8839ef")(label)}
    * Returns session result when the agent turn is complete.
    */
   handleMessage(message) {
+    if (this.wasInterrupted && message.type !== "result") {
+      return void 0;
+    }
     switch (message.type) {
       case "assistant": {
         let isCapMessage = false;
@@ -3214,32 +3072,11 @@ ${chalk.hex("#8839ef")(label)}
       }
       case "result": {
         this.hideLoader();
-        if (message.subtype === "error_max_turns") {
-          return {
-            type: "max_turns",
-            sessionId: message.session_id,
-            numTurns: message.num_turns
-          };
-        }
         if (this.usageCapReached) {
           return { type: "result", sessionId: message.session_id, success: false };
         }
         if (this.wasInterrupted) {
-          const thinkingSec2 = Math.round((this.nowMs() - this.turnStartTime) / 1e3);
-          this.messages.addChild(
-            new Text(
-              "\n " + chalk.yellow("⏺") + " " + chalk.yellow(__("Interrupted")),
-              0,
-              0
-            )
-          );
-          this.showInfo(
-            sprintf(
-              /* translators: %d: number of seconds */
-              __("Ran for %ds before interruption"),
-              thinkingSec2
-            )
-          );
+          this.showInterruptedNotice();
           return {
             type: "result",
             sessionId: message.session_id,
@@ -3304,108 +3141,1533 @@ ${chalk.hex("#8839ef")(label)}
     return void 0;
   }
 }
-const logger = new Logger();
-function isPromptAbortError(error) {
-  return error instanceof Error && ["AbortPromptError", "CancelPromptError", "ExitPromptError"].includes(error.name);
+function isRemoteSessionEnabled() {
+  return process.env.STUDIO_ENABLE_REMOTE_SESSION === "true";
 }
-function getErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
+const remoteSessionConfigSchema = z.object({
+  base_url: z.string().url().default("https://public-api.wordpress.com/wpcom/v2/telegram-bot"),
+  // `token` is the only required field; if omitted everywhere, falls back to the
+  // WordPress.com OAuth access token from ~/.studio/shared.json (i.e. /login).
+  token: z.string().min(1),
+  // Optional pinning. When set, `chat_id` filters polled messages and `bot` overrides
+  // the per-message bot identity for outgoing replies. When unset, the controller
+  // trusts the server's per-token authorization and echoes chat_id + bot from each
+  // polled message back into the response.
+  bot: z.string().min(1).optional(),
+  chat_id: z.number().int().optional(),
+  poll_interval_seconds: z.number().positive().default(2),
+  long_poll_timeout_seconds: z.number().positive().default(25),
+  max_message_chars: z.number().int().positive().max(4096).default(3800),
+  turn_timeout_seconds: z.number().positive().default(900)
+});
+class RemoteSessionConfigError extends Error {
+  constructor(message, missingFields = []) {
+    super(message);
+    this.missingFields = missingFields;
+    this.name = "RemoteSessionConfigError";
   }
-  return String(error);
 }
-async function runCommand(options) {
-  const ui = options.adapter;
-  const isJsonMode = ui instanceof JsonAdapter;
-  const resumeContext = resolveResumeSessionContext(options.resumeSession);
-  let currentProvider = resumeContext.provider ?? await resolveInitialAiProvider();
-  let currentModel = resumeContext.model ?? DEFAULT_MODEL;
-  ui.currentProvider = currentProvider;
-  ui.currentModel = currentModel;
-  if (options.activeSite) {
-    ui.activeSite = {
-      name: options.activeSite.name,
-      path: options.activeSite.path,
-      running: options.activeSite.running ?? false,
-      remote: options.activeSite.remote,
-      url: options.activeSite.url,
-      wpcomSiteId: options.activeSite.wpcomSiteId
-    };
+function readEnvOverrides() {
+  const overrides = {};
+  if (process.env.STUDIO_REMOTE_BASE_URL) {
+    overrides.base_url = process.env.STUDIO_REMOTE_BASE_URL;
   }
-  ui.start();
-  ui.showWelcome();
-  if (options.showLegacyCommandNotice && !isJsonMode) {
-    ui.showInfo(__('ⓘ The "studio ai" command is now "studio code".'));
+  if (process.env.STUDIO_REMOTE_TOKEN) {
+    overrides.token = process.env.STUDIO_REMOTE_TOKEN;
   }
-  let sessionRecorder;
-  let didDisableSessionPersistence = options.noSessionPersistence === true;
-  let sessionId = options.resumeSessionId ?? resumeContext.sessionId;
-  let persistQueue = Promise.resolve();
-  if (options.noSessionPersistence) {
-    ui.showInfo(__("Session persistence disabled (--no-session-persistence)."));
+  if (process.env.STUDIO_REMOTE_BOT) {
+    overrides.bot = process.env.STUDIO_REMOTE_BOT;
   }
-  const ensureSessionRecorder = async () => {
-    if (didDisableSessionPersistence) {
-      return void 0;
+  if (process.env.STUDIO_REMOTE_CHAT_ID) {
+    const parsed = Number(process.env.STUDIO_REMOTE_CHAT_ID);
+    if (Number.isFinite(parsed)) {
+      overrides.chat_id = parsed;
     }
-    if (sessionRecorder) {
-      return sessionRecorder;
+  }
+  return overrides;
+}
+async function readConfigFile() {
+  const configPath = getRemoteSessionConfigPath();
+  if (!fs__default.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const content = await readFile(configPath, { encoding: "utf8" });
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function loadRemoteSessionConfig(cliOverrides = {}) {
+  const fileValues = await readConfigFile();
+  const envOverrides = readEnvOverrides();
+  const merged = {
+    ...fileValues,
+    ...envOverrides,
+    ...cliOverrides
+  };
+  if (typeof merged.token !== "string" || merged.token.length === 0) {
+    const stored = await readAuthToken();
+    if (stored?.accessToken) {
+      merged.token = stored.accessToken;
+    }
+  }
+  const parseResult = remoteSessionConfigSchema.safeParse(merged);
+  if (parseResult.success) {
+    return parseResult.data;
+  }
+  const missing = [];
+  for (const issue of parseResult.error.issues) {
+    const field = issue.path[0];
+    if (typeof field === "string" && !missing.includes(field)) {
+      missing.push(field);
     }
+  }
+  const required = ["token"].filter((f) => missing.includes(f));
+  if (required.length > 0) {
+    throw new RemoteSessionConfigError(
+      `Remote session needs a bearer token to authenticate to ${"/local-agent-poll"}. Run \`studio code\` and \`/login\` to authenticate to WordPress.com, or set STUDIO_REMOTE_TOKEN, or put a "token" field in ~/.studio/remote-session.json.`,
+      required
+    );
+  }
+  throw new RemoteSessionConfigError(
+    `Remote session config is invalid: ${parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`,
+    []
+  );
+}
+const MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
+const MAX_LOG_ROTATIONS = 3;
+const BEARER_PATTERN = /Bearer\s+[A-Za-z0-9._\-+/=]+/g;
+const TOKEN_FIELD_PATTERN = /"token"\s*:\s*"[^"]*"/g;
+function redact(input) {
+  return input.replace(BEARER_PATTERN, "Bearer [redacted]").replace(TOKEN_FIELD_PATTERN, '"token":"[redacted]"');
+}
+function shouldLogDebug() {
+  return process.env.STUDIO_REMOTE_DEBUG === "1";
+}
+function rotateIfNeeded(logPath) {
+  let size;
+  try {
+    size = fs__default.statSync(logPath).size;
+  } catch {
+    return;
+  }
+  if (size < MAX_LOG_SIZE_BYTES) {
+    return;
+  }
+  const oldest = `${logPath}.${MAX_LOG_ROTATIONS}`;
+  try {
+    fs__default.rmSync(oldest, { force: true });
+  } catch {
+  }
+  for (let i = MAX_LOG_ROTATIONS - 1; i >= 1; i--) {
+    const src = `${logPath}.${i}`;
+    const dst = `${logPath}.${i + 1}`;
     try {
-      if (options.resumeSession) {
-        sessionRecorder = await AiSessionRecorder.open({
-          sessionId: options.resumeSession.summary.id,
-          filePath: options.resumeSession.summary.filePath,
-          linkedAgentSessionIds: options.resumeSession.summary.linkedAgentSessionIds
-        });
-      } else if (options.resumeSessionId) {
-        const sessions = await listAiSessions(getAiSessionsRootDirectory());
-        const existing = sessions.find(
-          (s) => s.linkedAgentSessionIds.includes(options.resumeSessionId)
-        );
-        if (!existing) {
-          throw new Error(
-            sprintf(
-              /* translators: %s: agent session ID */
-              __("No AI session found for resume ID: %s"),
-              options.resumeSessionId
-            )
-          );
-        }
-        sessionRecorder = await AiSessionRecorder.open({
-          sessionId: existing.id,
-          filePath: existing.filePath,
-          linkedAgentSessionIds: existing.linkedAgentSessionIds
-        });
-      } else {
-        sessionRecorder = await AiSessionRecorder.create();
+      if (fs__default.existsSync(src)) {
+        fs__default.renameSync(src, dst);
       }
-    } catch (error) {
-      didDisableSessionPersistence = true;
-      ui.showError(
-        sprintf(
-          /* translators: %s: error message */
-          __("Session persistence disabled: %s"),
-          getErrorMessage(error)
-        )
-      );
+    } catch {
     }
-    return sessionRecorder;
-  };
-  const persist = (callback) => {
-    persistQueue = persistQueue.then(async () => {
-      const recorder = await ensureSessionRecorder();
-      if (!recorder) {
+  }
+  try {
+    fs__default.renameSync(logPath, `${logPath}.1`);
+  } catch {
+  }
+}
+function ensureLogDir(logPath) {
+  try {
+    fs__default.mkdirSync(path__default.dirname(logPath), { recursive: true });
+  } catch {
+  }
+}
+class RemoteSessionLogger {
+  constructor(logPath = getRemoteSessionLogPath()) {
+    this.logPath = logPath;
+  }
+  write(level, message, meta) {
+    if (level === "debug" && !shouldLogDebug()) {
+      return;
+    }
+    ensureLogDir(this.logPath);
+    rotateIfNeeded(this.logPath);
+    const line = JSON.stringify({
+      t: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      msg: redact(message),
+      ...meta ? { meta: JSON.parse(redact(JSON.stringify(meta))) } : {}
+    }) + "\n";
+    try {
+      fs__default.appendFileSync(this.logPath, line, { encoding: "utf8" });
+    } catch {
+    }
+  }
+  debug(message, meta) {
+    this.write("debug", message, meta);
+  }
+  info(message, meta) {
+    this.write("info", message, meta);
+  }
+  warn(message, meta) {
+    this.write("warn", message, meta);
+  }
+  error(message, meta) {
+    this.write("error", message, meta);
+  }
+}
+const DEFAULT_INTERVAL_MS = 1e4;
+const DEFAULT_MAX_CHARS = 200;
+class ProgressStreamer {
+  constructor(options) {
+    this.timer = null;
+    this.pending = null;
+    this.lastPostAt = Number.NEGATIVE_INFINITY;
+    this.disposed = false;
+    this.onEvent = (event) => {
+      if (this.disposed) {
         return;
       }
-      try {
-        await callback(recorder);
-      } catch (error) {
-        sessionRecorder = void 0;
-        if (!didDisableSessionPersistence) {
-          didDisableSessionPersistence = true;
-          ui.showError(
-            sprintf(
+      if (event.type !== "info" && event.type !== "progress") {
+        return;
+      }
+      if (typeof event.message !== "string" || event.message.trim().length === 0) {
+        return;
+      }
+      const formatted = this.format(event.message);
+      const now = this.deps.now();
+      const sinceLast = now - this.lastPostAt;
+      if (sinceLast >= this.intervalMs) {
+        if (this.timer !== null) {
+          this.deps.clearTimeout(this.timer);
+          this.timer = null;
+        }
+        this.pending = null;
+        this.post(formatted);
+        return;
+      }
+      this.pending = formatted;
+      if (this.timer === null) {
+        const wait = Math.max(0, this.intervalMs - sinceLast);
+        this.timer = this.deps.setTimeout(() => this.flushPending(), wait);
+      }
+    };
+    this.config = options.config;
+    this.target = options.target;
+    this.deps = {
+      ...options.deps,
+      setTimeout: options.deps.setTimeout ?? setTimeout,
+      clearTimeout: options.deps.clearTimeout ?? clearTimeout,
+      now: options.deps.now ?? (() => Date.now())
+    };
+    this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    this.maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
+  }
+  stop() {
+    this.disposed = true;
+    if (this.timer !== null) {
+      this.deps.clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.pending = null;
+  }
+  flushPending() {
+    this.timer = null;
+    if (this.disposed) {
+      return;
+    }
+    if (this.pending === null) {
+      return;
+    }
+    const message = this.pending;
+    this.pending = null;
+    this.post(message);
+  }
+  post(text) {
+    this.lastPostAt = this.deps.now();
+    this.deps.respond(
+      this.config,
+      { chatId: this.target.chatId, bot: this.target.bot, text },
+      { logger: this.deps.logger, maxRetries: 0 }
+    ).catch((error) => {
+      this.deps.logger.warn("Progress post failed", {
+        chat_id: this.target.chatId,
+        error: error.message
+      });
+    });
+  }
+  format(raw) {
+    const oneLine = raw.replace(/\s+/g, " ").trim();
+    const truncated = oneLine.length > this.maxChars ? `${oneLine.slice(0, this.maxChars - 1)}…` : oneLine;
+    return `⏳ ${truncated}`;
+  }
+}
+const OPTION_LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+const ANSI_ESCAPE_PATTERN = new RegExp(String.fromCharCode(27) + "\\[[0-9;?]*[A-Za-z]", "g");
+function extractReply(input) {
+  const stripped = input.replyText ? stripAnsi(input.replyText).trim() : "";
+  const hasQuestions = input.questions && input.questions.length > 0;
+  if (!hasQuestions) {
+    if (!stripped) {
+      return null;
+    }
+    return input.isError ? `⚠️ ${stripped}` : stripped;
+  }
+  const formattedQuestions = formatQuestions(input.questions);
+  if (stripped) {
+    return `${stripped}
+
+${formattedQuestions}`;
+  }
+  return formattedQuestions;
+}
+function formatQuestions(questions) {
+  if (questions.length === 1) {
+    return formatSingleQuestion(questions[0]);
+  }
+  return questions.map((q, idx) => `${idx + 1}. ${formatSingleQuestion(q)}`).join("\n\n");
+}
+function formatSingleQuestion(q) {
+  const header = `**${q.question.trim()}**`;
+  const lines = q.options.map((option, idx) => {
+    const letter = OPTION_LETTERS[idx] ?? String(idx + 1);
+    const label = option.label.trim();
+    const description = option.description?.trim() ?? "";
+    if (description && description !== label) {
+      return `- ${letter}) ${label} — ${description}`;
+    }
+    return `- ${letter}) ${label}`;
+  });
+  lines.push('- _Or reply with anything else for "Other"._');
+  return `${header}
+
+${lines.join("\n")}`;
+}
+function stripAnsi(input) {
+  return input.replace(ANSI_ESCAPE_PATTERN, "");
+}
+function chunkReply(text, maxChars) {
+  if (text.length <= maxChars) {
+    return [text];
+  }
+  const segments = splitPreservingFences(text);
+  const chunks = [];
+  let current = "";
+  const flush = () => {
+    if (current) {
+      chunks.push(current);
+      current = "";
+    }
+  };
+  for (const segment of segments) {
+    if (segment.isCode) {
+      if (segment.text.length > maxChars) {
+        flush();
+        chunks.push(...splitLongCodeBlock(segment.text, maxChars));
+        continue;
+      }
+      if (current.length + (current ? 2 : 0) + segment.text.length > maxChars) {
+        flush();
+      }
+      current = current ? `${current}
+
+${segment.text}` : segment.text;
+      continue;
+    }
+    const pieces = splitPlainText(segment.text, maxChars);
+    for (const piece of pieces) {
+      if (!piece) {
+        continue;
+      }
+      if (current.length + (current ? 2 : 0) + piece.length > maxChars) {
+        flush();
+      }
+      current = current ? `${current}
+
+${piece}` : piece;
+    }
+  }
+  flush();
+  return chunks.length > 0 ? chunks : [text.slice(0, maxChars)];
+}
+function splitPreservingFences(input) {
+  const segments = [];
+  const fencePattern = /```[^\n]*\n[\s\S]*?```/g;
+  let cursor = 0;
+  let match;
+  while ((match = fencePattern.exec(input)) !== null) {
+    if (match.index > cursor) {
+      segments.push({ text: input.slice(cursor, match.index), isCode: false });
+    }
+    segments.push({ text: match[0], isCode: true });
+    cursor = match.index + match[0].length;
+  }
+  if (cursor < input.length) {
+    segments.push({ text: input.slice(cursor), isCode: false });
+  }
+  return segments;
+}
+function splitLongCodeBlock(block, maxChars) {
+  const firstNewline = block.indexOf("\n");
+  const header = firstNewline === -1 ? "```" : block.slice(0, firstNewline).trim();
+  const body = block.replace(/^```[^\n]*\n?/, "").replace(/\n?```\s*$/, "");
+  const overhead = header.length + 20;
+  const inner = Math.max(1, maxChars - overhead);
+  const lines = body.split("\n");
+  const slices = [];
+  let buf = "";
+  for (const line of lines) {
+    if (buf.length + line.length + 1 > inner) {
+      if (buf) {
+        slices.push(buf);
+        buf = "";
+      }
+      if (line.length > inner) {
+        for (let i = 0; i < line.length; i += inner) {
+          slices.push(line.slice(i, i + inner));
+        }
+        continue;
+      }
+    }
+    buf = buf ? `${buf}
+${line}` : line;
+  }
+  if (buf) {
+    slices.push(buf);
+  }
+  const total = slices.length;
+  return slices.map((slice, idx) => {
+    const label = `(part ${idx + 1}/${total})`;
+    return `${header}
+${label}
+${slice}
+\`\`\``;
+  });
+}
+function splitPlainText(input, maxChars) {
+  if (input.length <= maxChars) {
+    return [input];
+  }
+  const paragraphs = input.split(/\n\n+/);
+  const results = [];
+  for (const para of paragraphs) {
+    if (para.length <= maxChars) {
+      results.push(para);
+      continue;
+    }
+    const sentences = para.split(/(?<=[.!?])\s+/);
+    let buf = "";
+    for (const sentence of sentences) {
+      if (sentence.length > maxChars) {
+        if (buf) {
+          results.push(buf);
+          buf = "";
+        }
+        for (let i = 0; i < sentence.length; i += maxChars) {
+          results.push(sentence.slice(i, i + maxChars));
+        }
+        continue;
+      }
+      if (buf.length + sentence.length + 1 > maxChars) {
+        results.push(buf);
+        buf = sentence;
+      } else {
+        buf = buf ? `${buf} ${sentence}` : sentence;
+      }
+    }
+    if (buf) {
+      results.push(buf);
+    }
+  }
+  return results;
+}
+const remoteSessionStateSchema = z.object({
+  chat_id: z.number().int(),
+  session_id: z.string().min(1).optional(),
+  updated_at: z.string().optional()
+});
+async function readStateUnlocked() {
+  const statePath = getRemoteSessionStatePath();
+  if (!fs__default.existsSync(statePath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(statePath, { encoding: "utf8" });
+    return remoteSessionStateSchema.parse(JSON.parse(content));
+  } catch {
+    return null;
+  }
+}
+async function writeStateUnlocked(state) {
+  const statePath = getRemoteSessionStatePath();
+  const content = JSON.stringify(state, null, 2) + "\n";
+  await writeFile(statePath, content, { encoding: "utf8", mode: 384 });
+  try {
+    await fs__default.promises.chmod(statePath, 384);
+  } catch {
+  }
+}
+async function withStateLock(fn) {
+  const lockPath = getRemoteSessionStateLockFilePath();
+  await lockFileAsync(lockPath, {
+    wait: LOCKFILE_WAIT_TIME,
+    stale: LOCKFILE_STALE_TIME
+  });
+  try {
+    return await fn();
+  } finally {
+    await unlockFileAsync(lockPath);
+  }
+}
+async function readStateForChat(chatId) {
+  return withStateLock(async () => {
+    const state = await readStateUnlocked();
+    if (!state || state.chat_id !== chatId) {
+      return null;
+    }
+    return state;
+  });
+}
+async function writeSessionId(chatId, sessionId) {
+  await withStateLock(async () => {
+    const next = {
+      chat_id: chatId,
+      session_id: sessionId,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeStateUnlocked(next);
+  });
+}
+async function clearSessionId(chatId) {
+  await withStateLock(async () => {
+    const next = {
+      chat_id: chatId,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeStateUnlocked(next);
+  });
+}
+class TelegramAuthError extends Error {
+  constructor(status) {
+    super(`Telegram server returned auth error (HTTP ${status})`);
+    this.status = status;
+    this.name = "TelegramAuthError";
+  }
+}
+class TelegramTransientError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "TelegramTransientError";
+  }
+}
+class TelegramBadRequestError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "TelegramBadRequestError";
+  }
+}
+function assertSameHost(urlString, allowedHost) {
+  const u = new URL(urlString);
+  if (u.host !== allowedHost) {
+    throw new TelegramTransientError(
+      `Refusing to follow redirect to different host: ${u.host} (allowed: ${allowedHost})`
+    );
+  }
+}
+function normalizeBase(base) {
+  return new URL(base.endsWith("/") ? base : `${base}/`);
+}
+function buildUrl(baseUrl, pathName) {
+  const base = normalizeBase(baseUrl);
+  const joined = new URL(pathName.replace(/^\//, ""), base);
+  return joined.toString();
+}
+async function pollMessages(config, signal, context = {}) {
+  const url = buildUrl(config.base_url, "local-agent-poll");
+  const allowedHost = new URL(config.base_url).host;
+  assertSameHost(url, allowedHost);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.long_poll_timeout_seconds * 1e3);
+  const composite = composeSignals(signal, controller.signal);
+  const startedAt = Date.now();
+  context.logger?.debug("Poll start", { url });
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${config.token}`,
+        Accept: "application/json"
+      },
+      redirect: "manual",
+      signal: composite
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      if (signal?.aborted) {
+        throw error;
+      }
+      context.logger?.debug("Poll timed out", {
+        duration_ms: Date.now() - startedAt
+      });
+      return [];
+    }
+    const message = error.message ?? "unknown";
+    context.logger?.warn("Poll network error", { error: message });
+    throw new TelegramTransientError(`Network error polling Telegram: ${message}`);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  if (response.status === 401 || response.status === 403) {
+    context.logger?.error("Poll auth error", { status: response.status });
+    throw new TelegramAuthError(response.status);
+  }
+  if (response.status >= 500) {
+    context.logger?.warn("Poll 5xx", { status: response.status });
+    throw new TelegramTransientError(`Poll returned ${response.status}`, response.status);
+  }
+  if (response.status === 204) {
+    context.logger?.debug("Poll 204 (no messages)", {
+      duration_ms: Date.now() - startedAt
+    });
+    return [];
+  }
+  if (response.status >= 300 && response.status < 400) {
+    context.logger?.warn("Poll redirect", { status: response.status });
+    throw new TelegramTransientError(
+      `Unexpected redirect from poll endpoint: HTTP ${response.status}`,
+      response.status
+    );
+  }
+  if (!response.ok) {
+    context.logger?.warn("Poll unexpected status", { status: response.status });
+    throw new TelegramTransientError(
+      `Poll returned unexpected status ${response.status}`,
+      response.status
+    );
+  }
+  const text = await response.text();
+  if (!text.trim()) {
+    context.logger?.debug("Poll empty body", {
+      duration_ms: Date.now() - startedAt
+    });
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    context.logger?.warn("Poll body not JSON", {
+      body_preview: text.slice(0, 200)
+    });
+    return [];
+  }
+  const messages = extractMessages(parsed);
+  context.logger?.debug("Poll finished", {
+    status: response.status,
+    duration_ms: Date.now() - startedAt,
+    messages: messages.length
+  });
+  return messages;
+}
+function extractMessages(payload) {
+  if (!payload || typeof payload !== "object") {
+    return [];
+  }
+  const record = payload;
+  const candidates = Array.isArray(record.messages) ? record.messages : record.message && typeof record.message === "object" ? [record.message] : typeof record.chat_id === "number" ? [record] : [];
+  const out = [];
+  for (const entry of candidates) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const e = entry;
+    const chatId = e.chat_id;
+    const text = typeof e.message === "string" ? e.message : typeof e.text === "string" ? e.text : void 0;
+    if (typeof chatId !== "number" || typeof text !== "string") {
+      continue;
+    }
+    const bot = typeof e.bot === "string" ? e.bot : void 0;
+    out.push({ chat_id: chatId, text, bot });
+  }
+  return out;
+}
+async function respondMessage(config, params, options = {}) {
+  const url = buildUrl(config.base_url, "local-agent-respond");
+  const allowedHost = new URL(config.base_url).host;
+  assertSameHost(url, allowedHost);
+  const bot = params.bot ?? config.bot;
+  const body = JSON.stringify({
+    chat_id: params.chatId,
+    text: params.text,
+    bot
+  });
+  const maxRetries = options.maxRetries ?? 3;
+  let attempt = 0;
+  let lastError;
+  const logger2 = options.logger;
+  logger2?.debug("Respond start", {
+    chat_id: params.chatId,
+    bot,
+    text_length: params.text.length,
+    text_preview: params.text.slice(0, 120)
+  });
+  while (attempt <= maxRetries) {
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${config.token}`,
+          "Content-Type": "application/json"
+        },
+        body,
+        redirect: "manual",
+        signal: options.signal
+      });
+    } catch (error) {
+      lastError = error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw error;
+      }
+      logger2?.warn("Respond network error", {
+        attempt,
+        chat_id: params.chatId,
+        error: error.message
+      });
+      await backoff(attempt);
+      attempt++;
+      continue;
+    }
+    if (response.status === 401 || response.status === 403) {
+      logger2?.error("Respond auth error", {
+        status: response.status,
+        chat_id: params.chatId
+      });
+      throw new TelegramAuthError(response.status);
+    }
+    if (response.status >= 500) {
+      logger2?.warn("Respond 5xx", { status: response.status, attempt });
+      lastError = new TelegramTransientError(
+        `Respond returned ${response.status}`,
+        response.status
+      );
+      await backoff(attempt);
+      attempt++;
+      continue;
+    }
+    if (response.status >= 400) {
+      const text = await safeReadText(response);
+      logger2?.warn("Respond 4xx", {
+        status: response.status,
+        chat_id: params.chatId,
+        body_preview: text.slice(0, 200)
+      });
+      throw new TelegramBadRequestError(
+        `Respond returned ${response.status}${text ? `: ${text}` : ""}`,
+        response.status
+      );
+    }
+    if (!response.ok) {
+      logger2?.warn("Respond unexpected status", { status: response.status });
+      throw new TelegramTransientError(
+        `Respond returned unexpected status ${response.status}`,
+        response.status
+      );
+    }
+    logger2?.debug("Respond ok", {
+      status: response.status,
+      chat_id: params.chatId,
+      attempt
+    });
+    return;
+  }
+  logger2?.error("Respond failed after retries", {
+    chat_id: params.chatId,
+    max_retries: maxRetries
+  });
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new TelegramTransientError("Respond failed after retries");
+}
+async function safeReadText(response) {
+  try {
+    return await response.text();
+  } catch {
+    return "";
+  }
+}
+async function backoff(attempt) {
+  const baseMs = Math.min(3e4, 500 * Math.pow(2, attempt));
+  const jitter = Math.random() * 200;
+  await new Promise((resolve) => setTimeout(resolve, baseMs + jitter));
+}
+function composeSignals(a, b) {
+  if (!a) {
+    return b;
+  }
+  if (!b) {
+    return a;
+  }
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  if (a.aborted || b.aborted) {
+    controller.abort();
+  } else {
+    a.addEventListener("abort", onAbort, { once: true });
+    b.addEventListener("abort", onAbort, { once: true });
+  }
+  return controller.signal;
+}
+const STDERR_TAIL_BYTES = 2048;
+const SIGKILL_GRACE_MS = 2e3;
+const STALE_SESSION_PATTERNS = [
+  /no ai session found for resume id/i,
+  /session.*(not.?found|invalid|expired|unknown)/i,
+  /resume.*session.*(failed|invalid)/i
+];
+function extractResultPayload(event) {
+  const wrapped = event.message;
+  if (!wrapped || typeof wrapped !== "object" || wrapped.type !== "result") {
+    return null;
+  }
+  const isError = wrapped.is_error === true;
+  const sessionId = typeof wrapped.session_id === "string" ? wrapped.session_id : void 0;
+  let replyText;
+  if (typeof wrapped.result === "string" && wrapped.result.length > 0) {
+    replyText = wrapped.result;
+  } else if (isError && Array.isArray(wrapped.errors)) {
+    const msgs = wrapped.errors.filter((e) => typeof e === "string").join("\n");
+    if (msgs.length > 0) {
+      replyText = msgs;
+    }
+  }
+  return { sessionId, replyText, isError };
+}
+function parseEvent(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function appendStderrTail(current, chunk) {
+  const combined = current + chunk.toString("utf8");
+  if (combined.length <= STDERR_TAIL_BYTES) {
+    return combined;
+  }
+  return combined.slice(combined.length - STDERR_TAIL_BYTES);
+}
+function detectStaleSession(stderrTail, lastReply, isError) {
+  const haystack = `${stderrTail}
+${lastReply ?? ""}`;
+  if (!isError && !STALE_SESSION_PATTERNS.some((r) => r.test(haystack))) {
+    return false;
+  }
+  return STALE_SESSION_PATTERNS.some((r) => r.test(haystack));
+}
+async function runTurn(options) {
+  const cliEntry = options.cliEntry ?? process.argv[1];
+  const execPath = options.execPath ?? process.execPath;
+  const args = [cliEntry, "code", "--json", "--message-from-stdin"];
+  if (options.sessionId) {
+    args.push("--resume-session", options.sessionId);
+  }
+  const logger2 = options.logger;
+  const logContext = options.logContext ?? {};
+  const startedAt = Date.now();
+  logger2?.info("Spawning studio code subprocess", {
+    ...logContext,
+    exec: execPath,
+    cli_entry: cliEntry,
+    has_resume_session: options.sessionId !== void 0,
+    session_id: options.sessionId,
+    text_length: options.text.length,
+    text_preview: options.text.slice(0, 120),
+    timeout_ms: options.timeoutMs
+  });
+  let child;
+  try {
+    child = spawn(execPath, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: options.env ?? process.env,
+      // Explicitly never use a shell — text is attacker-controlled.
+      shell: false
+    });
+  } catch (error) {
+    const message = error.message ?? "spawn failed";
+    logger2?.error("Spawn failed", { ...logContext, error: message });
+    return {
+      status: "spawn_error",
+      isError: true,
+      stderrTail: message,
+      exitCode: null,
+      staleSession: false
+    };
+  }
+  logger2?.debug("Subprocess spawned", { ...logContext, pid: child.pid });
+  if (child.stdin) {
+    child.stdin.on("error", (error) => {
+      logger2?.warn("Subprocess stdin error", { ...logContext, error: error.message });
+    });
+    child.stdin.end(options.text, "utf8");
+  }
+  let capturedSessionId;
+  let replyText;
+  let isError = false;
+  let pausedQuestions;
+  let completedStatus;
+  let stderrTail = "";
+  let timedOut = false;
+  let aborted = false;
+  const rl = readline.createInterface({ input: child.stdout });
+  rl.on("line", (line) => {
+    const event = parseEvent(line);
+    if (!event) {
+      if (line.trim().length > 0) {
+        logger2?.debug("Subprocess stdout (non-JSON)", {
+          ...logContext,
+          line: line.slice(0, 500)
+        });
+      }
+      return;
+    }
+    options.onEvent?.(event);
+    if (event.type === "message") {
+      const extracted = extractResultPayload(event);
+      if (extracted) {
+        if (extracted.sessionId) {
+          capturedSessionId = extracted.sessionId;
+        }
+        if (extracted.replyText) {
+          replyText = extracted.replyText;
+        }
+        isError = isError || extracted.isError;
+        logger2?.debug("Event: message/result", {
+          ...logContext,
+          session_id: extracted.sessionId,
+          is_error: extracted.isError,
+          result_chars: extracted.replyText?.length ?? 0
+        });
+      } else {
+        logger2?.debug("Event: message", { ...logContext });
+      }
+    } else if (event.type === "question.asked") {
+      pausedQuestions = event.questions.map((q) => ({
+        question: q.question,
+        options: q.options.map((o) => ({
+          label: o.label,
+          description: o.description
+        }))
+      }));
+      logger2?.debug("Event: question.asked", {
+        ...logContext,
+        questions: pausedQuestions.length
+      });
+    } else if (event.type === "turn.completed") {
+      completedStatus = event.status;
+      if (event.sessionId) {
+        capturedSessionId = event.sessionId;
+      }
+      logger2?.debug("Event: turn.completed", {
+        ...logContext,
+        status: event.status,
+        session_id: event.sessionId
+      });
+    } else {
+      logger2?.debug("Event", { ...logContext, type: event.type });
+    }
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderrTail = appendStderrTail(stderrTail, chunk);
+    const text = chunk.toString("utf8");
+    if (text.trim().length > 0) {
+      logger2?.debug("Subprocess stderr", {
+        ...logContext,
+        chunk: text.slice(0, 500)
+      });
+    }
+  });
+  const overallTimer = setTimeout(() => {
+    timedOut = true;
+    killChild(child);
+  }, options.timeoutMs);
+  const onAbort = () => {
+    aborted = true;
+    killChild(child);
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  const exitCode = await new Promise((resolve) => {
+    child.once("exit", (code, signal) => {
+      logger2?.info("Subprocess exited", {
+        ...logContext,
+        exit_code: code,
+        signal,
+        duration_ms: Date.now() - startedAt
+      });
+      resolve(code);
+    });
+    child.once("error", (error) => {
+      logger2?.error("Subprocess error", { ...logContext, error: error.message });
+      resolve(null);
+    });
+  });
+  clearTimeout(overallTimer);
+  options.signal?.removeEventListener("abort", onAbort);
+  rl.close();
+  if (aborted) {
+    return {
+      status: "timeout",
+      sessionId: capturedSessionId,
+      replyText,
+      questions: pausedQuestions,
+      isError: true,
+      stderrTail,
+      exitCode,
+      staleSession: false
+    };
+  }
+  if (timedOut) {
+    return {
+      status: "timeout",
+      sessionId: capturedSessionId,
+      replyText,
+      questions: pausedQuestions,
+      isError: true,
+      stderrTail,
+      exitCode,
+      staleSession: false
+    };
+  }
+  const status = completedStatus ?? (isError ? "error" : "error");
+  const staleSession = options.sessionId !== void 0 && detectStaleSession(stderrTail, replyText, isError);
+  logger2?.info("Turn outcome", {
+    ...logContext,
+    status,
+    session_id: capturedSessionId,
+    exit_code: exitCode,
+    is_error: isError,
+    reply_chars: replyText?.length ?? 0,
+    questions: pausedQuestions?.length ?? 0,
+    stale_session: staleSession,
+    stderr_tail: stderrTail ? stderrTail.slice(-500) : ""
+  });
+  return {
+    status,
+    sessionId: capturedSessionId,
+    replyText,
+    questions: pausedQuestions,
+    isError,
+    stderrTail,
+    exitCode,
+    staleSession
+  };
+}
+function killChild(child) {
+  if (child.exitCode !== null || child.signalCode) {
+    return;
+  }
+  try {
+    child.kill("SIGTERM");
+  } catch {
+  }
+  setTimeout(() => {
+    if (child.exitCode === null && !child.signalCode) {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }
+  }, SIGKILL_GRACE_MS);
+}
+const DEFAULT_DEPS = {
+  poll: pollMessages,
+  respond: respondMessage,
+  runTurn,
+  readState: readStateForChat,
+  writeSession: writeSessionId,
+  clearSession: clearSessionId,
+  logger: new RemoteSessionLogger(),
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+};
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+async function postBestEffort(deps, config, target, text) {
+  try {
+    await deps.respond(
+      config,
+      { chatId: target.chatId, bot: target.bot, text },
+      { logger: deps.logger }
+    );
+  } catch (error) {
+    deps.logger.warn("Best-effort post failed", {
+      error: error.message
+    });
+  }
+}
+async function postChunks(deps, config, target, reply) {
+  const chunks = chunkReply(reply, config.max_message_chars);
+  deps.logger.info("Posting reply", {
+    chat_id: target.chatId,
+    chunks: chunks.length,
+    chars: reply.length
+  });
+  for (const chunk of chunks) {
+    await deps.respond(
+      config,
+      { chatId: target.chatId, bot: target.bot, text: chunk },
+      { logger: deps.logger }
+    );
+  }
+}
+async function handleTurn(deps, config, target, text, signal) {
+  let sessionId = (await deps.readState(target.chatId))?.session_id;
+  const started = Date.now();
+  const logContext = { chat_id: target.chatId };
+  const streamer = new ProgressStreamer({
+    config,
+    target,
+    deps: { respond: deps.respond, logger: deps.logger }
+  });
+  let outcome;
+  try {
+    outcome = await deps.runTurn({
+      text,
+      sessionId,
+      timeoutMs: config.turn_timeout_seconds * 1e3,
+      signal,
+      logger: deps.logger,
+      logContext,
+      onEvent: streamer.onEvent
+    });
+    if (!signal.aborted && outcome.staleSession && sessionId) {
+      deps.logger.info("Resume failed; retrying without session_id", {
+        ...logContext,
+        stale_session_id: sessionId
+      });
+      await deps.clearSession(target.chatId);
+      sessionId = void 0;
+      await postBestEffort(deps, config, target, "ℹ️ Session expired; started a new one.");
+      outcome = await deps.runTurn({
+        text,
+        sessionId: void 0,
+        timeoutMs: config.turn_timeout_seconds * 1e3,
+        signal,
+        logger: deps.logger,
+        logContext,
+        onEvent: streamer.onEvent
+      });
+    }
+  } finally {
+    streamer.stop();
+  }
+  if (outcome.sessionId && outcome.sessionId !== sessionId) {
+    await deps.writeSession(target.chatId, outcome.sessionId);
+  }
+  const duration = Date.now() - started;
+  deps.logger.info("Turn finished", {
+    chat_id: target.chatId,
+    duration_ms: duration,
+    status: outcome.status,
+    exit_code: outcome.exitCode,
+    chars_out: outcome.replyText?.length ?? 0,
+    session_id: outcome.sessionId,
+    aborted: signal.aborted
+  });
+  if (signal.aborted) {
+    return;
+  }
+  if (outcome.status === "timeout") {
+    await postBestEffort(deps, config, target, "⚠️ Turn took too long; aborted.");
+    return;
+  }
+  if (outcome.status === "spawn_error") {
+    await postBestEffort(
+      deps,
+      config,
+      target,
+      `⚠️ Local agent failed to start: ${truncate(outcome.stderrTail, 400)}`
+    );
+    return;
+  }
+  if (outcome.exitCode !== null && outcome.exitCode !== 0 && !outcome.replyText) {
+    const stderrSnippet = outcome.stderrTail ? truncate(outcome.stderrTail, 500) : "";
+    const message = stderrSnippet ? `⚠️ Local agent error: ${stderrSnippet}` : "⚠️ Local agent error (no output).";
+    await postBestEffort(deps, config, target, message);
+    return;
+  }
+  const reply = extractReply({
+    replyText: outcome.replyText,
+    questions: outcome.questions,
+    isError: outcome.isError
+  });
+  if (reply === null) {
+    await postBestEffort(deps, config, target, "⚠️ Local agent did not return a result.");
+    return;
+  }
+  await postChunks(deps, config, target, reply);
+}
+async function runPollLoop(options) {
+  const deps = { ...DEFAULT_DEPS, ...options.deps };
+  const { config } = options;
+  const abortController = new AbortController();
+  let detachRequested = false;
+  let detachAnnounced = false;
+  if (config.chat_id !== void 0) {
+    const state = await deps.readState(config.chat_id);
+    const resuming = Boolean(state?.session_id);
+    const cwd = options.cwd ?? process.cwd();
+    const attachMessage = `🟢 Local agent attached. Working dir: ${cwd}. ${resuming ? "Resuming previous session." : "New session."}`;
+    await deps.respond(
+      config,
+      {
+        chatId: config.chat_id,
+        bot: config.bot,
+        text: attachMessage
+      },
+      { logger: deps.logger }
+    );
+    deps.logger.info("Attached (pinned chat)", { chat_id: config.chat_id, resuming });
+  } else {
+    deps.logger.info("Attached (open to any chat authorized by the bearer)");
+  }
+  options.onAttached?.();
+  const announceDetach = async (reason) => {
+    if (detachAnnounced) {
+      return;
+    }
+    detachAnnounced = true;
+    deps.logger.info("Detaching", { reason });
+    if (config.chat_id !== void 0) {
+      await postBestEffort(
+        deps,
+        config,
+        { chatId: config.chat_id, bot: config.bot },
+        "🔴 Local agent detached."
+      );
+    }
+  };
+  const detach = async () => {
+    detachRequested = true;
+    abortController.abort();
+    await announceDetach("requested");
+  };
+  const loop = async () => {
+    let backoffAttempt = 0;
+    batchLoop: while (!detachRequested) {
+      let batch;
+      try {
+        batch = await deps.poll(config, abortController.signal, { logger: deps.logger });
+        backoffAttempt = 0;
+      } catch (error) {
+        if (error instanceof TelegramAuthError) {
+          deps.logger.error("Auth error; detaching", { status: error.status });
+          if (config.chat_id !== void 0) {
+            await postBestEffort(
+              deps,
+              config,
+              { chatId: config.chat_id, bot: config.bot },
+              "⚠️ Bad token; detaching."
+            );
+          }
+          detachRequested = true;
+          process.exitCode = 1;
+          break;
+        }
+        if (error instanceof TelegramTransientError) {
+          const delay = Math.min(3e4, 1e3 * Math.pow(2, backoffAttempt));
+          deps.logger.warn("Transient poll error; backing off", {
+            status: error.status,
+            delay_ms: delay
+          });
+          backoffAttempt++;
+          await deps.sleep(delay);
+          continue;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          break;
+        }
+        deps.logger.error("Fatal poll error; detaching", {
+          error: error.message
+        });
+        detachRequested = true;
+        break;
+      }
+      if (batch.length === 0) {
+        await deps.sleep(config.poll_interval_seconds * 1e3);
+        continue;
+      }
+      for (const polled of batch) {
+        if (detachRequested) {
+          break batchLoop;
+        }
+        if (config.chat_id !== void 0 && polled.chat_id !== config.chat_id) {
+          deps.logger.warn("Ignoring message for unbound chat", {
+            polled_chat_id: polled.chat_id,
+            bound_chat_id: config.chat_id
+          });
+          continue;
+        }
+        const target = {
+          chatId: polled.chat_id,
+          bot: config.bot ?? polled.bot
+        };
+        const text = polled.text.trim();
+        deps.logger.info("Polled message", {
+          chat_id: polled.chat_id,
+          bot: polled.bot,
+          text_length: polled.text.length,
+          preview: text.slice(0, 80)
+        });
+        if (text.length === 0) {
+          deps.logger.warn("Skipping empty message", {
+            chat_id: polled.chat_id
+          });
+          await postBestEffort(
+            deps,
+            config,
+            target,
+            "⚠️ Empty message ignored. Send some text or `/new` to start over."
+          );
+          continue;
+        }
+        if (text.toLowerCase() === "/new") {
+          await deps.clearSession(polled.chat_id);
+          try {
+            await deps.respond(
+              config,
+              {
+                chatId: target.chatId,
+                bot: target.bot,
+                text: "🆕 Started a new conversation."
+              },
+              { logger: deps.logger }
+            );
+          } catch (error) {
+            if (error instanceof TelegramBadRequestError) {
+              deps.logger.warn("Respond 4xx on /new ack", { status: error.status });
+            } else {
+              throw error;
+            }
+          }
+          continue;
+        }
+        try {
+          await handleTurn(deps, config, target, polled.text, abortController.signal);
+        } catch (error) {
+          if (error instanceof TelegramAuthError) {
+            deps.logger.error("Auth error during respond; detaching", {
+              status: error.status
+            });
+            detachRequested = true;
+            process.exitCode = 1;
+            break batchLoop;
+          }
+          if (error instanceof TelegramBadRequestError) {
+            deps.logger.warn("Respond 4xx; dropping chunk", { status: error.status });
+            continue;
+          }
+          deps.logger.error("Turn failed", { error: error.message });
+          await postBestEffort(
+            deps,
+            config,
+            target,
+            `⚠️ Local agent error: ${truncate(error.message, 500)}`
+          );
+        }
+      }
+    }
+    await announceDetach(detachAnnounced ? "already-announced" : "loop-exit");
+  };
+  const done = loop();
+  return {
+    done,
+    detach
+  };
+}
+async function runRemoteSession(overrides = {}) {
+  const config = await loadRemoteSessionConfig(overrides);
+  const logger2 = new RemoteSessionLogger();
+  const logPath = getRemoteSessionLogPath();
+  logger2.info("Remote session starting", {
+    base_url: config.base_url,
+    has_chat_id: config.chat_id !== void 0,
+    bot: config.bot,
+    poll_interval_seconds: config.poll_interval_seconds,
+    long_poll_timeout_seconds: config.long_poll_timeout_seconds,
+    turn_timeout_seconds: config.turn_timeout_seconds,
+    debug: process.env.STUDIO_REMOTE_DEBUG === "1"
+  });
+  process.stdout.write(`Remote session log: ${logPath}
+`);
+  const { done, detach } = await runPollLoop({
+    config,
+    deps: { logger: logger2 },
+    onAttached: () => {
+      const target = config.chat_id !== void 0 ? `chat ${config.chat_id}` : "any chat authorized by the bearer";
+      process.stdout.write(`Remote session attached → ${target}.
+Press Ctrl-C to detach.
+`);
+    }
+  });
+  const signalCleanup = [];
+  const installSignal = (signal) => {
+    const handler = () => {
+      logger2.info("Signal received; detaching", { signal });
+      void detach();
+    };
+    process.on(signal, handler);
+    signalCleanup.push(() => process.off(signal, handler));
+  };
+  installSignal("SIGINT");
+  installSignal("SIGTERM");
+  const onExit = () => {
+    if (config.chat_id === void 0) {
+      return;
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 2e3);
+    void respondMessage(
+      config,
+      {
+        chatId: config.chat_id,
+        bot: config.bot,
+        text: "🔴 Local agent ended (process exit)."
+      },
+      { signal: controller.signal, maxRetries: 0, logger: logger2 }
+    ).catch(() => void 0).finally(() => clearTimeout(timer));
+  };
+  process.once("beforeExit", onExit);
+  try {
+    await done;
+    process.stdout.write("Remote session detached.\n");
+  } finally {
+    for (const cleanup of signalCleanup) {
+      cleanup();
+    }
+    process.off("beforeExit", onExit);
+  }
+}
+const logger = new Logger();
+function isPromptAbortError(error) {
+  return error instanceof Error && ["AbortPromptError", "CancelPromptError", "ExitPromptError"].includes(error.name);
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function readAllStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+async function runCommand(options) {
+  const ui = options.adapter;
+  const isJsonMode = ui instanceof JsonAdapter;
+  const resumeContext = resolveResumeSessionContext(options.resumeSession);
+  let currentProvider = resumeContext.provider ?? await resolveInitialAiProvider();
+  let currentModel = resumeContext.model ?? DEFAULT_MODEL;
+  ui.currentProvider = currentProvider;
+  ui.currentModel = currentModel;
+  if (options.activeSite) {
+    ui.activeSite = {
+      name: options.activeSite.name,
+      path: options.activeSite.path,
+      running: options.activeSite.running ?? false,
+      remote: options.activeSite.remote,
+      url: options.activeSite.url,
+      wpcomSiteId: options.activeSite.wpcomSiteId
+    };
+  }
+  ui.start();
+  ui.showWelcome();
+  if (options.showLegacyCommandNotice && !isJsonMode) {
+    ui.showInfo(__('ⓘ The "studio ai" command is now "studio code".'));
+  }
+  let sessionRecorder;
+  let didDisableSessionPersistence = options.noSessionPersistence === true;
+  let sessionId = options.resumeSessionId ?? resumeContext.sessionId;
+  let persistQueue = Promise.resolve();
+  if (options.noSessionPersistence) {
+    ui.showInfo(__("Session persistence disabled (--no-session-persistence)."));
+  }
+  const ensureSessionRecorder = async () => {
+    if (didDisableSessionPersistence) {
+      return void 0;
+    }
+    if (sessionRecorder) {
+      return sessionRecorder;
+    }
+    try {
+      if (options.resumeSession) {
+        sessionRecorder = await AiSessionRecorder.open({
+          sessionId: options.resumeSession.summary.id,
+          filePath: options.resumeSession.summary.filePath,
+          linkedAgentSessionIds: options.resumeSession.summary.linkedAgentSessionIds
+        });
+      } else if (options.resumeSessionId) {
+        const sessions = await listAiSessions(getAiSessionsRootDirectory());
+        const existing = sessions.find(
+          (s) => s.linkedAgentSessionIds.includes(options.resumeSessionId)
+        );
+        if (!existing) {
+          throw new Error(
+            sprintf(
+              /* translators: %s: agent session ID */
+              __("No AI session found for resume ID: %s"),
+              options.resumeSessionId
+            )
+          );
+        }
+        sessionRecorder = await AiSessionRecorder.open({
+          sessionId: existing.id,
+          filePath: existing.filePath,
+          linkedAgentSessionIds: existing.linkedAgentSessionIds
+        });
+      } else {
+        sessionRecorder = await AiSessionRecorder.create();
+      }
+    } catch (error) {
+      didDisableSessionPersistence = true;
+      ui.showError(
+        sprintf(
+          /* translators: %s: error message */
+          __("Session persistence disabled: %s"),
+          getErrorMessage(error)
+        )
+      );
+    }
+    return sessionRecorder;
+  };
+  const persist = (callback) => {
+    persistQueue = persistQueue.then(async () => {
+      const recorder = await ensureSessionRecorder();
+      if (!recorder) {
+        return;
+      }
+      try {
+        await callback(recorder);
+      } catch (error) {
+        sessionRecorder = void 0;
+        if (!didDisableSessionPersistence) {
+          didDisableSessionPersistence = true;
+          ui.showError(
+            sprintf(
               /* translators: %s: error message */
               __("Session persistence disabled: %s"),
               getErrorMessage(error)
@@ -3654,73 +4916,70 @@ ${prompt}`;
       env,
       model: currentModel,
       resume: sessionId,
-      autoApprove: options.autoApprove ?? isJsonMode,
       activeSite: site,
       wpcomAccessToken,
       onAskUser: (questions) => askUserAndPersistAnswers(questions)
     });
+    let interruptRequested = false;
+    let resolveInterrupt = () => void 0;
+    const interruptPromise = new Promise((resolve) => {
+      resolveInterrupt = () => resolve("interrupted");
+    });
     ui.onInterrupt = () => {
+      if (interruptRequested) {
+        return;
+      }
+      interruptRequested = true;
       void agentQuery.interrupt();
+      resolveInterrupt();
     };
-    let maxTurnsResult;
-    let turnStatus = "interrupted";
-    try {
+    const turnState = { status: "interrupted" };
+    const consumeAgentTurn = async () => {
       for await (const message of agentQuery) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+        if (interruptRequested) {
+          continue;
+        }
         const result = ui.handleMessage(message);
         await persist((recorder2) => recorder2.recordSdkMessage(message, timestamp));
         if (result) {
           sessionId = result.sessionId;
           await persist((recorder2) => recorder2.recordAgentSessionId(result.sessionId));
-          if (result.type === "max_turns") {
-            maxTurnsResult = {
-              numTurns: result.numTurns
-            };
-            turnStatus = "max_turns";
-          } else if (result.interrupted) {
-            turnStatus = "interrupted";
+          if (result.interrupted) {
+            turnState.status = "interrupted";
           } else {
-            turnStatus = result.success ? "success" : "error";
+            turnState.status = result.success ? "success" : "error";
           }
         }
       }
-    } catch (error) {
-      turnStatus = "error";
-      if (isJsonMode) {
-        throw error;
+    };
+    const consumeAgentTurnResult = consumeAgentTurn().catch((error) => {
+      if (interruptRequested) {
+        turnState.status = "interrupted";
+        return;
       }
+      turnState.status = "error";
       if (!(ui instanceof AiChatUI && ui.hasErrorBeenSurfaced())) {
         ui.showError(getErrorMessage(error));
       }
-    } finally {
-      await persist((recorder2) => recorder2.recordTurnClosed(turnStatus));
-      ui.endAgentTurn();
-    }
-    if (maxTurnsResult) {
-      ui.showInfo(
-        sprintf(
-          /* translators: %d: number of turns used */
-          _n("Used %d turn", "Used %d turns", maxTurnsResult.numTurns),
-          maxTurnsResult.numTurns
-        )
-      );
-      const answer = await ui.askUser([
-        {
-          question: __("Reached the turn limit. Continue?"),
-          options: [
-            { label: "Yes", description: __("Resume where the agent left off") },
-            { label: "No", description: __("Stop here") }
-          ]
-        }
+      if (isJsonMode) {
+        throw error;
+      }
+    });
+    try {
+      const result = await Promise.race([
+        consumeAgentTurnResult.then(() => "completed"),
+        interruptPromise
       ]);
-      const choice = Object.values(answer)[0]?.toLowerCase();
-      if (choice === "yes") {
-        ui.addUserMessage("Continue");
-        return runAgentTurn("Continue from where you left off.");
+      if (result === "interrupted") {
+        turnState.status = "interrupted";
       }
+    } finally {
+      await persist((recorder2) => recorder2.recordTurnClosed(turnState.status));
+      ui.endAgentTurn();
     }
     const hasTerminalError = ui instanceof AiChatUI && ui.hasErrorBeenSurfaced();
-    if (turnStatus === "error" && !isJsonMode && !hasTerminalError) {
+    if (turnState.status === "error" && !isJsonMode && !hasTerminalError) {
       if (retryAttempt >= MAX_RETRY_ATTEMPTS) {
         ui.showInfo(
           __("The server has not recovered after multiple attempts. Please try again later.")
@@ -3747,8 +5006,7 @@ ${prompt}`;
       }
     }
     return {
-      status: turnStatus,
-      usage: maxTurnsResult
+      status: turnState.status
     };
   }
   if (isJsonMode && options.initialMessage) {
@@ -3756,7 +5014,7 @@ ${prompt}`;
       ui.addUserMessage(options.initialMessage);
       const result = await runAgentTurn(options.initialMessage);
       const jsonStatus = result.status === "interrupted" ? "error" : result.status;
-      ui.emitTurnCompleted(jsonStatus, result.usage);
+      ui.emitTurnCompleted(jsonStatus);
     } catch (error) {
       process.exitCode = 1;
       handleAgentTurnError(error);
@@ -3827,7 +5085,7 @@ ${prompt}`;
         } else {
           ui.addUserMessage(prompt);
           try {
-            await runAgentTurn(`Run the /${cmd.name} skill using the Skill tool.`);
+            await runAgentTurn(buildSkillInvocationPrompt(cmd.name));
           } catch (error) {
             handleAgentTurnError(error);
           }
@@ -3852,7 +5110,7 @@ const registerCommand = (yargs) => {
     command: "$0 [message]",
     describe: __("AI agent for building WordPress"),
     builder: (yargs2) => {
-      return yargs2.positional("message", {
+      let chain = yargs2.positional("message", {
         type: "string",
         description: __("Initial message to send to the AI agent")
       }).option("path", {
@@ -3865,9 +5123,6 @@ const registerCommand = (yargs) => {
         type: "boolean",
         default: false,
         description: __("Output events as NDJSON to stdout (headless mode)")
-      }).option("auto-approve", {
-        type: "boolean",
-        description: __("Auto-approve all tool calls (defaults to true in --json mode)")
       }).option("resume-session", {
         type: "string",
         hidden: true,
@@ -3880,8 +5135,27 @@ const registerCommand = (yargs) => {
         type: "boolean",
         default: true,
         description: __("Record this code session to disk")
-      }).check((argv) => {
-        if (argv.json && !argv.message) {
+      });
+      if (isRemoteSessionEnabled()) {
+        chain = chain.option("remote-session", {
+          type: "boolean",
+          default: false,
+          description: __("Attach to Telegram and drive studio code remotely")
+        }).option("remote-chat-id", {
+          type: "number",
+          description: __("Override the Telegram chat id to bind to")
+        }).option("remote-bot", {
+          type: "string",
+          description: __("Override the Telegram bot name to use for replies")
+        }).option("message-from-stdin", {
+          type: "boolean",
+          hidden: true,
+          default: false,
+          description: __("Read the initial message from stdin (for headless drivers)")
+        });
+      }
+      return chain.check((argv) => {
+        if (argv.json && !argv.message && !argv.remoteSession && !argv.messageFromStdin) {
           throw new Error(__("--json requires an initial message argument"));
         }
         return true;
@@ -3890,20 +5164,57 @@ const registerCommand = (yargs) => {
     handler: async (argv) => {
       try {
         const typedArgv = argv;
+        if (typedArgv.remoteSession && isRemoteSessionEnabled()) {
+          try {
+            await runRemoteSession({
+              chat_id: typedArgv.remoteChatId,
+              bot: typedArgv.remoteBot
+            });
+          } catch (error) {
+            if (error instanceof RemoteSessionConfigError) {
+              process.stderr.write(`${error.message}
+`);
+              process.exitCode = 1;
+              return;
+            }
+            throw error;
+          }
+          return;
+        }
         const noSessionPersistence = typedArgv.sessionPersistence === false;
         const adapter = typedArgv.json ? new JsonAdapter() : new AiChatUI();
+        let initialMessage = typedArgv.message;
+        if (typedArgv.messageFromStdin && isRemoteSessionEnabled()) {
+          initialMessage = await readAllStdin();
+          if (!initialMessage) {
+            process.stderr.write(
+              `${__("--message-from-stdin requires non-empty input on stdin")}
+`
+            );
+            process.exitCode = 1;
+            return;
+          }
+        }
         if (adapter instanceof JsonAdapter && typedArgv.permissionResponse) {
           adapter.permissionResponse = JSON.parse(typedArgv.permissionResponse);
         }
         const sitePath = typeof argv.path === "string" ? argv.path : void 0;
+        let activeSite;
+        if (sitePath && typedArgv.siteName) {
+          activeSite = { name: typedArgv.siteName, path: sitePath };
+        } else if (sitePath) {
+          const matchedSite = await findSiteByFolder(sitePath);
+          if (matchedSite) {
+            activeSite = { name: matchedSite.name, path: matchedSite.path };
+          }
+        }
         await runCommand({
           adapter,
-          initialMessage: typedArgv.message,
+          initialMessage,
           resumeSessionId: typedArgv.resumeSession,
           noSessionPersistence,
-          autoApprove: typedArgv.autoApprove,
           showLegacyCommandNotice: argv._[0] === "ai",
-          activeSite: sitePath && typedArgv.siteName ? { name: typedArgv.siteName, path: sitePath } : void 0
+          activeSite
         });
       } catch (error) {
         if (error instanceof LoggerError) {