ask-pro 0.1.58 → 0.1.63

package/README.md

@@ -88,6 +88,27 @@ Use `ask-pro --help` for the full CLI. For multiline prompts, use
 `--prompt-file`. Prefer `--no-temporary` when recovery matters; `--temporary`
 requires Temporary Chat. The [skill](skills/ask-pro/SKILL.md) has agent guidance.
 
+When Pro asks native questions, ask-pro returns `awaiting_answers`, prints each
+question and its numbered choices, and saves `QUESTIONS.json`. The calling agent
+can answer directly, or ask its user when a decision needs their input. Write a
+UTF-8 JSON file using the emitted `request_id`, with one answer per question:
+
+```json
+{ "requestId": "<request_id>", "answers": [2, 3, "A workshop on incident response"] }
+```
+
+Numbers select 1-based options; strings enter free text. Then continue the same chat:
+
+```powershell
+ask-pro --resume <session-id> --answers answers.json
+```
+
+`--answers -` accepts piped JSON. ask-pro requests a native pause; if ChatGPT expires
+the cards anyway, it sends your answers as a reply in the same conversation.
+Keep the session's original Temporary Chat mode when answering.
+Further question rounds use the same
+flow; `--status` repeats pending questions and `--harvest` waits for a final answer.
+
 ## Optional GitHub context
 
 Use `--github` to check the GitHub connection in ask-pro's signed-in ChatGPT

package/dist/bin/ask-pro-cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import "dotenv/config";
 import { AssistantStoppedError } from "../src/browser/errors.js";
+import { AssistantQuestionsError } from "../src/browser/actions/questions.js";
+import { readAskProQuestions } from "../src/ask-pro/questions.js";
 import { GITHUB_SETUP_URL, GitHubConnectionRequiredError } from "../src/browser/actions/github.js";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -28,6 +30,9 @@ program
     "copy",
 ]))
     .option("--resume [session-id]", "resume a prepared or waiting ask-pro session")
+    .addOption(new Option("--answers <path>", "answer native questions from JSON; use - for stdin")
+    .implies({ resume: true })
+    .conflicts(["status", "harvest", "copy", "dryRun", "promptFile"]))
     .option("--status [session-id]", "show ask-pro session status")
     .option("--harvest [session-id]", "print harvested ANSWER.md for a session")
     .option("--copy [session-id]", "print the copy target for a session")
@@ -52,6 +57,8 @@ program
 await program.parseAsync(process.argv);
 async function runAskPro(question, options) {
     const cwd = resolveProjectCwd(options);
+    if (options.answers && question.trim())
+        throw new Error("Use --answers with --resume, without a question argument.");
     await pruneExpiredAskProSessions({ cwd });
     if (options.status !== undefined) {
         const { status } = await readAskProStatus({ cwd, sessionId: optionSessionId(options.status) });
@@ -115,6 +122,12 @@ async function runAskPro(question, options) {
     }
     if (options.resume !== undefined) {
         const { status } = await readAskProStatus({ cwd, sessionId: optionSessionId(options.resume) });
+        if (options.answers !== undefined && options.temporary !== undefined) {
+            const metadata = await readBrowserMetadata(cwd, status.sessionId);
+            const savedTemporary = metadata?.temporary ?? metadata?.url?.includes("temporary-chat=true");
+            if (savedTemporary !== options.temporary)
+                throw new Error("Cannot change Temporary Chat mode while answering questions; resume with the saved mode.");
+        }
         const effectiveOptions = mergeStatusOptions(options, status);
         const resumeCommand = buildResumeCommand(status.sessionId, effectiveOptions, cwd);
         const harvestCommand = buildHarvestCommand(status.sessionId, cwd);
@@ -192,6 +205,10 @@ function optionSessionId(value) {
 }
 async function submitOrResumeBrowserSession(cwd, sessionId, options) {
     const { status } = await readAskProStatus({ cwd, sessionId });
+    if (options.answers !== undefined && status.status !== "AWAITING_ANSWERS")
+        throw new Error("This session is not waiting for answers. Resume without --answers to inspect it.");
+    if (options.answers === "-" && process.stdin.isTTY)
+        throw new Error("--answers - requires piped stdin.");
     if (status.status === "COMPLETED" || status.status === "HARVESTED") {
         printStatusRecord(status, {
             ...(await readBrowserPreflight(cwd, status)),
@@ -200,6 +217,7 @@ async function submitOrResumeBrowserSession(cwd, sessionId, options) {
         return;
     }
     if (status.status === "WAITING" ||
+        status.status === "AWAITING_ANSWERS" ||
         status.status === "WAIT_TIMED_OUT" ||
         status.status === "INCOMPLETE_ANSWER" ||
         status.status === "NEEDS_USER_AUTH" ||
@@ -210,6 +228,11 @@ async function submitOrResumeBrowserSession(cwd, sessionId, options) {
                 sessionId,
                 temporary: options.temporary,
                 verbose: options.verbose,
+                answers: options.answers === undefined
+                    ? undefined
+                    : options.answers === "-"
+                        ? await readStdin()
+                        : await fs.readFile(path.resolve(cwd, options.answers), "utf8"),
             });
         }
         catch (error) {
@@ -218,7 +241,7 @@ async function submitOrResumeBrowserSession(cwd, sessionId, options) {
                 printStatusRecord(paused);
                 return;
             }
-            if (error instanceof AssistantStoppedError) {
+            if (error instanceof AssistantStoppedError || error instanceof AssistantQuestionsError) {
                 const { status: stopped } = await readAskProStatus({ cwd, sessionId });
                 printStatusRecord(stopped, await readBrowserPreflight(cwd, stopped));
                 return;
@@ -255,7 +278,7 @@ async function submitOrResumeBrowserSession(cwd, sessionId, options) {
             printStatusRecord(paused);
             return;
         }
-        if (error instanceof AssistantStoppedError) {
+        if (error instanceof AssistantStoppedError || error instanceof AssistantQuestionsError) {
             const { status: stopped } = await readAskProStatus({ cwd, sessionId });
             printStatusRecord(stopped, await readBrowserPreflight(cwd, stopped));
             return;
@@ -388,6 +411,8 @@ function actionForStatus(status) {
     switch (status.status) {
         case "NEEDS_GITHUB_CONNECTION":
             return "connect_github_then_resume";
+        case "AWAITING_ANSWERS":
+            return "answer_questions";
         case "DRY_RUN_COMPLETE":
         case "INCOMPLETE_ANSWER":
         case "READY_TO_SUBMIT":
@@ -411,6 +436,7 @@ function shouldPrintResume(status) {
         "DRY_RUN_COMPLETE",
         "INCOMPLETE_ANSWER",
         "WAITING",
+        "AWAITING_ANSWERS",
         "READY_TO_SUBMIT",
         "NEEDS_USER_AUTH",
         "NEEDS_GITHUB_CONNECTION",
@@ -431,7 +457,7 @@ function isAnswerBearingStatus(status) {
     return ["COMPLETED", "HARVESTED"].includes(status.status);
 }
 async function readRecoverableCapturedAnswer(cwd, status) {
-    if (status.status === "INCOMPLETE_ANSWER") {
+    if (status.status === "INCOMPLETE_ANSWER" || status.status === "AWAITING_ANSWERS") {
         return null;
     }
     try {
@@ -457,7 +483,25 @@ async function readBrowserPreflightForSession(cwd, sessionId) {
         return {};
     const profileDir = typeof metadata.profileDir === "string" ? metadata.profileDir : undefined;
     const profile = profileMode(profileDir);
+    const questions = {};
+    if (metadata.status === "awaiting_answers") {
+        const request = await readAskProQuestions(getAskProSessionPaths(cwd, sessionId).dir);
+        questions.request_id = request.requestId;
+        questions.questions = request.questions.length;
+        questions.questions_file = `.ask-pro/sessions/${sessionId}/QUESTIONS.json`;
+        questions.reply = `${buildSessionCommand(cwd, ["--resume", sessionId, "--answers", "<answers.json>"])}`;
+        questions.answers_format =
+            '{"requestId":"<request_id>","answers":[1,"free text"]} (one answer per question; choices are 1-based)';
+        for (const [index, question] of request.questions.entries()) {
+            questions[`question_${index + 1}`] = question.question;
+            questions[`options_${index + 1}`] = question.options
+                .map((option, choice) => `${choice + 1}: ${option}`)
+                .join("; ");
+            questions[`free_text_${index + 1}`] = question.freeText;
+        }
+    }
     return compactFields({
+        ...questions,
         profile,
         profile_path: profile && profileDir ? collapseHome(profileDir) : undefined,
         chrome: chromeMode(metadata),

package/dist/src/ask-pro/browserRunner.js

@@ -2,6 +2,8 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { DEFAULT_CHATGPT_BROWSER_MODEL_LABEL } from "../browser/chatgptModelCatalog.js";
 import { AssistantStoppedError, BrowserAutomationError } from "../browser/errors.js";
+import { AssistantQuestionsError } from "../browser/actions/questions.js";
+import { readAskProQuestions, parseQuestionAnswers, writeAskProQuestions } from "./questions.js";
 import { GitHubConnectionRequiredError } from "../browser/actions/github.js";
 import { askProAgentIdForLegacyBrowserProfileDir, askProAgentIdForManagedBrowserProfileDir, askProBrowserProfileDirForAgentId, ensureAskProBrowserProfileDir, isLegacyAskProManagedBrowserProfileDir, isAskProManagedBrowserProfileDir, resolveAskProAgentId, } from "../browser/profilePaths.js";
 import { runBrowserMode } from "../browserMode.js";
@@ -245,6 +247,12 @@ async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary: req
             });
             throw new AskProNeedsAuthError(sessionId, browserProfile, classifyBrowserError(error));
         }
+        if (error instanceof AssistantQuestionsError) {
+            await writeAskProQuestions(paths.dir, error.questions);
+            await writeTerminalBrowserMetadata(cwd, sessionId, "awaiting_answers", "questions");
+            await updateAskProStatus({ cwd, sessionId, status: "AWAITING_ANSWERS", reason: "questions" });
+            throw error;
+        }
         if (error instanceof AssistantStoppedError) {
             await writeTerminalBrowserMetadata(cwd, sessionId, "incomplete_answer", "stopped_without_answer");
             await updateAskProStatus({
@@ -281,13 +289,28 @@ export async function resumeAskProBrowserSession(options) {
     const { dir } = getAskProSessionPaths(options.cwd, options.sessionId);
     return withSessionControllerLease(dir, () => resumeAskProBrowserSessionWithLease(options));
 }
-async function resumeAskProBrowserSessionWithLease({ cwd, sessionId, temporary, verbose, }) {
+async function resumeAskProBrowserSessionWithLease({ cwd, sessionId, temporary, verbose, answers, }) {
     const paths = getAskProSessionPaths(cwd, sessionId);
     const prompt = await readAskProPrompt({ cwd, sessionId });
     const { status: sessionStatus } = await readAskProStatus({ cwd, sessionId });
+    const request = answers !== undefined ? await readAskProQuestions(paths.dir) : undefined;
+    if (answers !== undefined && sessionStatus.status !== "AWAITING_ANSWERS")
+        throw new Error("This session is not waiting for answers. Resume without --answers to inspect it.");
+    const questionAnswers = request && answers !== undefined
+        ? {
+            questions: request.questions,
+            answers: parseQuestionAnswers(answers, request),
+            submissionState: { started: false },
+        }
+        : undefined;
     const artifactsRequested = sessionStatus.artifacts === true;
     const logger = buildAskProBrowserLogger(cwd, sessionId, verbose);
     const metadata = await readBrowserMetadata(paths.browser);
+    if (questionAnswers &&
+        temporary !== undefined &&
+        temporary !== (metadata.temporary ?? isTemporaryAskProUrl(metadata.url ?? ""))) {
+        throw new Error("Cannot change Temporary Chat mode while answering questions; resume with the saved mode.");
+    }
     const effectiveTemporary = temporary ?? metadata.temporary;
     const chatgptUrl = effectiveTemporary === true
         ? ASK_PRO_TEMPORARY_CHATGPT_URL
@@ -377,6 +400,10 @@ async function resumeAskProBrowserSessionWithLease({ cwd, sessionId, temporary,
             thinkingTime: "pro",
             startMinimized: false,
         }, logger, {
+            questionAnswers,
+            afterQuestionsAnswered: async () => {
+                await fs.rm(path.join(paths.dir, "QUESTIONS.json"), { force: true });
+            },
             promptPreview: prompt,
             chromeModeCb: async (chromeMode) => {
                 const current = await readBrowserMetadata(paths.browser).catch(() => metadata);
@@ -473,6 +500,12 @@ async function resumeAskProBrowserSessionWithLease({ cwd, sessionId, temporary,
             });
             throw new AskProNeedsAuthError(sessionId, fallbackProfile, classifyBrowserError(error));
         }
+        if (error instanceof AssistantQuestionsError) {
+            await writeAskProQuestions(paths.dir, error.questions);
+            await writeTerminalBrowserMetadata(cwd, sessionId, "awaiting_answers", "questions");
+            await updateAskProStatus({ cwd, sessionId, status: "AWAITING_ANSWERS", reason: "questions" });
+            throw error;
+        }
         if (error instanceof AssistantStoppedError) {
             await writeTerminalBrowserMetadata(cwd, sessionId, "incomplete_answer", "stopped_without_answer");
             await updateAskProStatus({
@@ -494,11 +527,12 @@ async function resumeAskProBrowserSessionWithLease({ cwd, sessionId, temporary,
             throw error;
         }
         const reason = error instanceof Error ? error.message : String(error);
-        await writeTerminalBrowserMetadata(cwd, sessionId, "failed", reason);
+        const answersPending = questionAnswers && !questionAnswers.submissionState.started;
+        await writeTerminalBrowserMetadata(cwd, sessionId, answersPending ? "awaiting_answers" : questionAnswers ? "wait_timed_out" : "failed", reason);
         await updateAskProStatus({
             cwd,
             sessionId,
-            status: "FAILED",
+            status: answersPending ? "AWAITING_ANSWERS" : questionAnswers ? "WAIT_TIMED_OUT" : "FAILED",
             reason,
         });
         throw error;

package/dist/src/ask-pro/questions.js

@@ -0,0 +1,40 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { atomicWriteFile } from "./atomicWrite.js";
+export async function readAskProQuestions(sessionDir) {
+    return JSON.parse(await fs.readFile(path.join(sessionDir, "QUESTIONS.json"), "utf8"));
+}
+export async function writeAskProQuestions(sessionDir, questions) {
+    const previous = await readAskProQuestions(sessionDir).catch(() => null);
+    const request = {
+        requestId: previous && JSON.stringify(previous.questions) === JSON.stringify(questions)
+            ? previous.requestId
+            : randomUUID(),
+        questions,
+    };
+    await atomicWriteFile(path.join(sessionDir, "QUESTIONS.json"), `${JSON.stringify(request, null, 2)}\n`);
+}
+export function parseQuestionAnswers(raw, request) {
+    const value = JSON.parse(raw);
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Answers must be a JSON object with requestId and answers.");
+    }
+    if (value?.requestId !== request.requestId)
+        throw new Error("Answers belong to a different question request; read the current QUESTIONS.json.");
+    if (!Array.isArray(value.answers) || value.answers.length !== request.questions.length) {
+        throw new Error("Provide one answer per question in answers, in question order.");
+    }
+    for (const [index, answer] of value.answers.entries()) {
+        const question = request.questions[index];
+        if (typeof answer === "number" &&
+            Number.isInteger(answer) &&
+            answer >= 1 &&
+            answer <= question.options.length)
+            continue;
+        if (typeof answer === "string" && answer.trim() && question.freeText)
+            continue;
+        throw new Error(`Question ${index + 1}: choose a numbered option or provide nonempty free text.`);
+    }
+    return value.answers;
+}

package/dist/src/browser/actions/assistantResponse.js

@@ -4,6 +4,7 @@ import { logDomFailure } from "../domDebug.js";
 import { buildClickDispatcher } from "./domEvents.js";
 import { AssistantStoppedError } from "../errors.js";
 import { readComposerSnapshot, submitPrompt } from "./promptComposer.js";
+import { AssistantQuestionsError, readAssistantQuestions } from "./questions.js";
 const ASSISTANT_POLL_TIMEOUT_ERROR = "assistant-response-watchdog-timeout";
 export function createAssistantContinuation(Runtime, Input, logger, inputGuard, state = { used: false }) {
     return async (turnIndex) => {
@@ -60,14 +61,18 @@ export async function waitForAssistantResponse(Runtime, timeoutMs, logger, minTu
     const deadline = Date.now() + timeoutMs;
     while (true) {
         try {
-            return await waitForAssistantResponseOnce(Runtime, Math.max(1, deadline - Date.now()), logger, minTurnIndex, expectedConversationId);
+            const answer = await waitForAssistantResponseOnce(Runtime, Math.max(1, deadline - Date.now()), logger, minTurnIndex, expectedConversationId);
+            const questions = await readAssistantQuestions(Runtime);
+            if (questions)
+                throw new AssistantQuestionsError(questions);
+            return answer;
         }
         catch (error) {
-            if (!(error instanceof AssistantStoppedError))
-                throw error;
             await Runtime.evaluate({
                 expression: "window.__askProCancelResponseObserver?.()",
             }).catch(() => undefined);
+            if (!(error instanceof AssistantStoppedError))
+                throw error;
             if (!continueResponse || Date.now() >= deadline)
                 throw error;
             minTurnIndex = await continueResponse(error.turnIndex);
@@ -126,6 +131,7 @@ async function waitForAssistantResponseOnce(Runtime, timeoutMs, logger, minTurnI
             }
             else if (source === "poll") {
                 pollerAbort.abort();
+                evaluationPromise.catch(() => undefined);
                 throw error;
             }
             else if (source === "evaluation") {
@@ -341,6 +347,9 @@ async function pollAssistantCompletion(Runtime, timeoutMs, minTurnIndex, expecte
         if (abortSignal?.aborted) {
             return null;
         }
+        const questions = await readAssistantQuestions(Runtime);
+        if (questions)
+            throw new AssistantQuestionsError(questions);
         const snapshot = await readAssistantSnapshot(Runtime, minTurnIndex, expectedConversationId);
         const normalized = normalizeAssistantSnapshot(snapshot);
         if (normalized) {

package/dist/src/browser/actions/promptComposer.js

@@ -332,7 +332,7 @@ export async function submitPrompt(deps, prompt, logger) {
             composerState: postVerification,
         });
     }
-    const clicked = await attemptSendButton(runtime, logger, deps?.attachmentNames, deps.inputTimeoutMs ?? undefined);
+    const clicked = await attemptSendButton(runtime, logger, deps?.attachmentNames, deps.inputTimeoutMs ?? undefined, deps.submissionState);
     if (!clicked) {
         const canSubmitViaEnter = await canSubmitPromptViaEnter(runtime);
         if (!canSubmitViaEnter) {
@@ -342,6 +342,8 @@ export async function submitPrompt(deps, prompt, logger) {
                 code: "unsafe-enter-submit",
             });
         }
+        if (deps.submissionState)
+            deps.submissionState.started = true;
         await input.dispatchKeyEvent({
             type: "keyDown",
             ...ENTER_KEY_EVENT,
@@ -539,7 +541,7 @@ async function waitForDomReady(Runtime, logger, timeoutMs = 10_000) {
 export function buildComposerSendReadinessExpressionForTest() {
     return buildComposerSendReadinessExpression();
 }
-async function attemptSendButton(Runtime, logger, attachmentNames, inputTimeoutMs) {
+async function attemptSendButton(Runtime, logger, attachmentNames, inputTimeoutMs, submissionState) {
     const needAttachment = Array.isArray(attachmentNames) && attachmentNames.length > 0;
     const deadline = Date.now() +
         (needAttachment ? Math.max(15_000, Math.min(inputTimeoutMs ?? 30_000, 30_000)) : 8_000);
@@ -572,6 +574,8 @@ async function attemptSendButton(Runtime, logger, attachmentNames, inputTimeoutM
                 continue;
             }
         }
+        if (submissionState)
+            submissionState.started = true;
         const { result } = await Runtime.evaluate({
             expression: buildComposerSendClickExpression(),
             returnByValue: true,
@@ -579,6 +583,8 @@ async function attemptSendButton(Runtime, logger, attachmentNames, inputTimeoutM
         if (result.value === "clicked") {
             return true;
         }
+        if (submissionState)
+            submissionState.started = false;
         if (result.value === "stop-button") {
             throw new BrowserAutomationError("Refusing to click ChatGPT stop control as a send button.", {
                 stage: "submit-prompt",

package/dist/src/browser/actions/questions.js

@@ -0,0 +1,195 @@
+import { readComposerSnapshot, submitPrompt } from "./promptComposer.js";
+import { CONVERSATION_TURN_SELECTOR } from "../constants.js";
+export class AssistantQuestionsError extends Error {
+    questions;
+    constructor(questions) {
+        super("ChatGPT is waiting for answers to its questions.");
+        this.questions = questions;
+        this.name = "AssistantQuestionsError";
+    }
+}
+// This function also runs in Chrome; keep it independent of module state.
+async function questionCards(answers, expected, submission = { started: false }) {
+    const selector = '[data-codex-composer-request-navigation="true"]';
+    const visible = (node) => {
+        const rect = node.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0 && !node.closest('[inert], [aria-hidden="true"]');
+    };
+    const card = () => Array.from(document.querySelectorAll(selector)).find(visible);
+    let root = card();
+    if (!root)
+        return null;
+    // Native pointer interaction cancels ChatGPT's automatic question dismissal.
+    root.dispatchEvent(new PointerEvent("pointerdown", { bubbles: true, pointerType: "mouse" }));
+    const pause = () => new Promise((resolve) => setTimeout(resolve, 100));
+    const read = () => {
+        root = card();
+        if (!root)
+            throw new Error("ChatGPT question card disappeared.");
+        return {
+            question: root.querySelector(".text-size-chat")?.innerText.trim() ?? "",
+            options: Array.from(root.querySelectorAll('[role="radio"]')).map((option) => option.getAttribute("aria-label") ?? option.innerText.replace(/^\d+\s*/, "").trim()),
+            freeText: Boolean(root.querySelector('[role="textbox"], textarea, input:not([type="file"])')),
+        };
+    };
+    const position = () => {
+        const match = root?.innerText.match(/(?:^|\n)(\d+) of (\d+)(?:\n|$)/);
+        return match ? { index: Number(match[1]), count: Number(match[2]) } : { index: 1, count: 1 };
+    };
+    const move = async (direction) => {
+        const before = position().index;
+        const button = root?.querySelector(`button[aria-label="${direction} question"]`);
+        if (!button || button.disabled)
+            throw new Error("Cannot browse ChatGPT's questions.");
+        button.click();
+        const deadline = Date.now() + 5_000;
+        do {
+            await pause();
+            read();
+            if (position().index !== before)
+                return;
+        } while (Date.now() < deadline);
+        throw new Error("ChatGPT did not change questions.");
+    };
+    while (position().index > 1)
+        await move("Previous");
+    const questions = [];
+    const count = position().count;
+    for (let index = 0; index < count; index++) {
+        const current = read();
+        if (!current.question)
+            throw new Error("Cannot read ChatGPT's question.");
+        questions.push(current);
+        if (index + 1 < count)
+            await move("Next");
+    }
+    while (position().index > 1)
+        await move("Previous");
+    if (!answers)
+        return questions;
+    if (JSON.stringify(questions) !== JSON.stringify(expected)) {
+        throw new Error("ChatGPT's questions changed; read the current questions before answering.");
+    }
+    if (answers.length !== questions.length)
+        throw new Error("Provide one answer per question.");
+    for (const [index, answer] of answers.entries()) {
+        const question = questions[index];
+        if (typeof answer === "number") {
+            if (!Number.isInteger(answer) || answer < 1 || answer > question.options.length) {
+                throw new Error(`Question ${index + 1}: choose 1-${question.options.length} or provide free text.`);
+            }
+        }
+        else if (typeof answer !== "string" || !answer.trim() || !question.freeText) {
+            throw new Error(`Question ${index + 1}: a nonempty free-text answer is required.`);
+        }
+    }
+    for (const [index, answer] of answers.entries()) {
+        read();
+        if (typeof answer === "number") {
+            const options = Array.from(root.querySelectorAll('[role="radio"]'));
+            if (index + 1 === count)
+                submission.started = true;
+            options[answer - 1].click();
+            if (index + 1 < count) {
+                const deadline = Date.now() + 5_000;
+                do {
+                    await pause();
+                    read();
+                } while (position().index === index + 1 && Date.now() < deadline);
+                if (position().index !== index + 2)
+                    throw new Error(`ChatGPT did not accept answer for question ${index + 1}.`);
+            }
+        }
+        else {
+            const input = root.querySelector('[role="textbox"], textarea, input:not([type="file"])');
+            if (!input)
+                throw new Error("ChatGPT's free-text input is missing.");
+            input.focus();
+            if (input instanceof HTMLInputElement || input instanceof HTMLTextAreaElement) {
+                const prototype = input instanceof HTMLInputElement
+                    ? HTMLInputElement.prototype
+                    : HTMLTextAreaElement.prototype;
+                Object.getOwnPropertyDescriptor(prototype, "value").set.call(input, answer);
+                input.dispatchEvent(new Event("input", { bubbles: true }));
+            }
+            else {
+                const selection = window.getSelection();
+                const range = document.createRange();
+                range.selectNodeContents(input);
+                selection?.removeAllRanges();
+                selection?.addRange(range);
+                document.execCommand("insertText", false, answer);
+            }
+            await pause();
+            if ((input instanceof HTMLInputElement || input instanceof HTMLTextAreaElement
+                ? input.value
+                : Array.from(input.children)
+                    .map((child) => (child.textContent ? child.innerText : ""))
+                    .join("\n")) !== answer) {
+                throw new Error(`Could not enter answer for question ${index + 1}.`);
+            }
+        }
+        if (typeof answer === "string" && index + 1 < count)
+            await move("Next");
+    }
+    // Choice clicks advance/submit natively; a custom answer uses the card's submit button.
+    if (typeof answers.at(-1) === "string") {
+        const submit = root.querySelector("[data-request-input-skip]");
+        if (!submit || submit.disabled || !/^(submit|send|continue)$/i.test(submit.innerText.trim()))
+            throw new Error("ChatGPT's answer submit button is not ready.");
+        submission.started = true;
+        submit.click();
+    }
+    const deadline = Date.now() + 5_000;
+    while (card() && Date.now() < deadline)
+        await pause();
+    if (card())
+        throw new Error("ChatGPT did not accept the answers; inspect the question card before retrying.");
+    return questions;
+}
+export function buildQuestionCardsExpression(answers, expected) {
+    // tsx preserves function names with __name; Chrome only needs the function itself.
+    const call = `(${questionCards.toString()})(${JSON.stringify(answers) ?? "undefined"}, ${JSON.stringify(expected) ?? "undefined"}, submission)`;
+    return `(() => { const __name = (fn) => fn; const submission = { started: false }; return ${answers ? `${call}.then(questions => ({ questions, started: submission.started }), error => ({ error: String(error), started: submission.started }))` : call}; })()`;
+}
+export async function readAssistantQuestions(Runtime) {
+    const evaluation = await Runtime.evaluate({
+        expression: buildQuestionCardsExpression(),
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    if (evaluation.exceptionDetails)
+        throw new Error(evaluation.exceptionDetails.exception?.description ?? "Cannot read ChatGPT's questions.");
+    return Array.isArray(evaluation.result.value) && evaluation.result.value.length > 0
+        ? evaluation.result.value
+        : null;
+}
+export async function answerAssistantQuestions(Runtime, Input, logger, answers, expected, submissionState = { started: false }) {
+    // A lost transport may have submitted successfully; never replay that attempt automatically.
+    submissionState.started = true;
+    const evaluation = await Runtime.evaluate({
+        expression: buildQuestionCardsExpression(answers, expected),
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    if (evaluation.exceptionDetails)
+        throw new Error(evaluation.exceptionDetails.exception?.description ?? "Cannot answer ChatGPT's questions.");
+    const value = evaluation.result.value;
+    submissionState.started = value.started;
+    if (value.error)
+        throw new Error(value.error);
+    if (!value.questions) {
+        // Native snooze returned 409 in the canary; expired cards need a reply in the same chat.
+        const composer = await readComposerSnapshot(Runtime);
+        if (composer.activeValue.trim())
+            throw new Error("The ChatGPT composer has a draft; clear it before answering expired questions.");
+        const prompt = `Answers to your clarification questions:\n\n${expected.map((question, index) => `${index + 1}. ${question.question}\n${typeof answers[index] === "number" ? question.options[answers[index] - 1] : answers[index]}`).join("\n\n")}\n\nContinue the original request using these answers.`;
+        const { result } = await Runtime.evaluate({
+            expression: `document.querySelectorAll(${JSON.stringify(CONVERSATION_TURN_SELECTOR)}).length`,
+            returnByValue: true,
+        });
+        const baselineTurns = result.value;
+        await submitPrompt({ runtime: Runtime, input: Input, baselineTurns, submissionState }, prompt, logger);
+        return baselineTurns;
+    }
+}

package/dist/src/browser/actions/thinkingStatus.js

@@ -1,5 +1,5 @@
 import { formatElapsed } from "../format.js";
-import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR } from "../constants.js";
+import { ASSISTANT_ROLE_SELECTOR, CONVERSATION_TURN_SELECTOR, STOP_BUTTON_SELECTOR, } from "../constants.js";
 const THINKING_STALE_HINT_MS = 10 * 60_000;
 export function startThinkingStatusMonitor(Runtime, logger, options = {}) {
     const intervalMs = resolveThinkingStatusInterval(options.intervalMs);
@@ -200,13 +200,15 @@ function buildThinkingStatusExpression() {
         [node.textContent, node.getAttribute?.('aria-label'), node.getAttribute?.('title')]
           .some((label) => normalize(label) === expected),
       );
-    if (hasControl('answer now') && hasControl('stop answering')) {
+    const stopActive = hasControl('stop answering') ||
+      Array.from(document.querySelectorAll(${JSON.stringify(STOP_BUTTON_SELECTOR)})).some(isVisible);
+    if (hasControl('answer now') && stopActive) {
       return {
         message: 'pro gate active',
         source: 'inline',
       };
     }
-    if (hasControl('stop answering')) {
+    if (stopActive) {
       return { message: 'active', source: 'inline' };
     }
     const looksLikeThinking = (node) => {

package/dist/src/browser/constants.js

@@ -32,8 +32,8 @@ export const ANSWER_SELECTORS = [
 ];
 export const CONVERSATION_TURN_SELECTOR = 'article[data-testid^="conversation-turn"], div[data-testid^="conversation-turn"], section[data-testid^="conversation-turn"], ' +
     "article[data-message-author-role], div[data-message-author-role], section[data-message-author-role], " +
-    "article[data-turn], div[data-turn], section[data-turn]";
-export const ASSISTANT_ROLE_SELECTOR = '[data-message-author-role="assistant"], [data-turn="assistant"]';
+    'article[data-turn], div[data-turn], section[data-turn], [data-content-search-unit-key$=":assistant"], [data-content-search-unit-key$=":user"]';
+export const ASSISTANT_ROLE_SELECTOR = '[data-message-author-role="assistant"], [data-turn="assistant"], [data-markdown-text-style="assistant-message"]';
 export const CLOUDFLARE_TITLE = "just a moment";
 export const PROMPT_PRIMARY_SELECTOR = "#prompt-textarea";
 export const PROMPT_FALLBACK_SELECTOR = 'textarea[name="prompt-textarea"]';

package/dist/src/browser/index.js

@@ -19,6 +19,7 @@ import { estimateTokenCount, withRetries, delay } from "./utils.js";
 import { formatElapsed } from "./format.js";
 import { CHATGPT_URL, CONVERSATION_TURN_SELECTOR, DEFAULT_MODEL_STRATEGY } from "./constants.js";
 import { AssistantStoppedError, BrowserAutomationError } from "./errors.js";
+import { AssistantQuestionsError } from "./actions/questions.js";
 import { defaultAskProBrowserProfileDir } from "./profilePaths.js";
 import { applyPageLanguageOverrides, seedChromeProfileLanguage } from "./language.js";
 import { alignPromptEchoPair, buildPromptEchoMatcher, extractConversationIdFromUrl, withTimeout, } from "./reattachHelpers.js";
@@ -1292,6 +1293,12 @@ export async function runBrowserMode(options) {
     }
     catch (error) {
         let normalizedError = error instanceof Error ? error : new Error(String(error));
+        if (normalizedError instanceof AssistantQuestionsError) {
+            preserveBrowserOnError = true;
+            preserveWindowStateOnError = true;
+            await emitRuntimeHint();
+            throw normalizedError;
+        }
         if (normalizedError instanceof GitHubConnectionRequiredError) {
             preserveBrowserOnError = true;
             await revealAuthenticatedWindow("github-connection-required");

package/dist/src/browser/reattach.js

@@ -1,4 +1,5 @@
 import { AssistantStoppedError } from "./errors.js";
+import { AssistantQuestionsError, answerAssistantQuestions, } from "./actions/questions.js";
 import { createAssistantContinuation } from "./actions/assistantResponse.js";
 import CDP from "chrome-remote-interface";
 import os from "node:os";
@@ -113,6 +114,7 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         ? await acquireReattachRunLease(directUserDataDir, resolvedConfig.profileLockTimeoutMs, logger)
         : null;
     let closeConnection = null;
+    let answeringQuestions = false;
     try {
         const liveRuntime = await refreshAttachRuntime(runtime, logger).catch(() => runtime);
         if (!liveRuntime.chromePort && !liveRuntime.chromeBrowserWSEndpoint) {
@@ -152,7 +154,8 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
                     })),
                 close: async () => undefined,
             };
-        closeConnection = connection.close;
+        closeConnection =
+            browserWSEndpoint && !deps.connect ? connection.close : () => connection.client.close();
         const connectedTargetId = "targetId" in connection ? connection.targetId : target?.targetId;
         const ownsConnectedTarget = Boolean(!resolvedConfig.browserTabRef &&
             liveRuntime.chromeTargetId &&
@@ -213,7 +216,14 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         const pingTimeoutMs = Math.min(5_000, Math.max(1_500, Math.floor(timeoutMs * 0.05)));
         await withTimeout(Runtime.evaluate({ expression: "1+1", returnByValue: true }), pingTimeoutMs, "Reattach target did not respond");
         await ensureConversationOpen();
-        const minTurnIndex = await readConversationTurnIndex(Runtime, logger);
+        let minTurnIndex = await readConversationTurnIndex(Runtime, logger);
+        if (deps.questionAnswers) {
+            answeringQuestions = true;
+            const replyBoundary = await answerAssistantQuestions(Runtime, Input, logger, deps.questionAnswers.answers, deps.questionAnswers.questions, deps.questionAnswers.submissionState);
+            if (replyBoundary !== undefined)
+                minTurnIndex = replyBoundary;
+            await deps.afterQuestionsAnswered?.();
+        }
         const promptEcho = buildPromptEchoMatcher(deps.promptPreview);
         const answer = await withTimeout(waitForResponse(Runtime, timeoutMs, logger, minTurnIndex ?? undefined, runtime.conversationId, createAssistantContinuation(Runtime, Input, logger, undefined, deps.continuationState)), timeoutMs + 5_000, "Reattach response timed out");
         const recovered = await recoverPromptEcho(Runtime, answer, promptEcho, logger, minTurnIndex, timeoutMs);
@@ -228,7 +238,7 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
                 markdown: aligned.answerMarkdown,
             },
         });
-        await connection.close().catch(() => undefined);
+        await closeConnection().catch(() => undefined);
         closeConnection = null;
         const keepBrowserOpen = Boolean(resolvedConfig.keepBrowser ||
             resolvedConfig.browserTabRef ||
@@ -261,7 +271,10 @@ export async function resumeBrowserSession(runtime, config, logger, deps = {}) {
         await closeConnection?.().catch(() => undefined);
         await releaseReattachRunLease(reattachRunLease, logger);
         reattachRunLease = null;
-        if (error instanceof AssistantStoppedError)
+        if (error instanceof AssistantStoppedError ||
+            error instanceof AssistantQuestionsError ||
+            answeringQuestions ||
+            deps.questionAnswers?.submissionState.started)
             throw error;
         const message = error instanceof Error ? error.message : String(error);
         logger(`Existing Chrome reattach failed (${message}); reopening browser to locate the session.`);
@@ -482,7 +495,13 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
         const waitForResponse = deps.waitForAssistantResponse ?? waitForAssistantResponse;
         const captureMarkdown = deps.captureAssistantMarkdown ?? captureAssistantMarkdown;
         const timeoutMs = resolved.timeoutMs ?? 120_000;
-        const minTurnIndex = await readConversationTurnIndex(Runtime, logger);
+        let minTurnIndex = await readConversationTurnIndex(Runtime, logger);
+        if (deps.questionAnswers) {
+            const replyBoundary = await answerAssistantQuestions(Runtime, client.Input, logger, deps.questionAnswers.answers, deps.questionAnswers.questions, deps.questionAnswers.submissionState);
+            if (replyBoundary !== undefined)
+                minTurnIndex = replyBoundary;
+            await deps.afterQuestionsAnswered?.();
+        }
         const promptEcho = buildPromptEchoMatcher(deps.promptPreview);
         const answer = await waitForResponse(Runtime, timeoutMs, logger, minTurnIndex ?? undefined, runtime.conversationId, createAssistantContinuation(Runtime, client.Input, logger, undefined, deps.continuationState));
         const recovered = await recoverPromptEcho(Runtime, answer, promptEcho, logger, minTurnIndex, timeoutMs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ask-pro",
-  "version": "0.1.58",
+  "version": "0.1.63",
   "description": "Browser-backed ChatGPT Pro escalation for hard engineering questions.",
   "keywords": [
     "agents",

package/skills/ask-pro/SKILL.md

@@ -162,6 +162,16 @@ Normal `ask-pro` stdout is compact TOON-style telemetry. Use `state`, `action`,
 `resume`, and `harvest` to decide the next command. Browser progress may appear
 on stderr and can be ignored unless diagnosing a stuck run.
 
+`AWAITING_ANSWERS` / `answer_questions` means Pro is asking native interactive
+questions. Read the printed questions/options or `QUESTIONS.json`, answer from
+the caller's context, and ask the human only for decisions you cannot infer.
+Write UTF-8 JSON `{"requestId":"<request_id>","answers":[2,3,"free text"]}`
+with one answer per question in order, then run the emitted
+`ask-pro --resume <session-id> --answers <answers.json>` command. Numbers select
+1-based choices; strings enter the native free-text field. `--answers -` accepts
+piped JSON. Do not submit defaults or treat the question preamble as the answer.
+Repeat for further question rounds, then harvest the final answer normally.
+
 When present, use `profile`, `profile_path`, `chrome`, and `language` only as
 diagnostic hints. They tell you whether the run used the shared profile, an
 isolated agent profile, saved DevTools state, and English browser steering.