ask-pro 0.1.53 → 0.1.61

package/README.md

@@ -1,8 +1,8 @@
 # ask-pro
 
 `ask-pro` gives coding agents a focused ChatGPT Pro second opinion through a
-human-logged-in browser. The calling agent supplies the context and owns the
-result; ask-pro never applies generated code.
+human-logged-in browser. The calling agent supplies the question and evidence,
+and owns the result; ask-pro never applies generated code.
 
 ## Install
 
@@ -72,8 +72,9 @@ ask-pro --no-temporary --prompt-file question.md --files src --files tests
 ```
 
 ask-pro selects `Latest` when available, otherwise the highest numbered available
-GPT model, with `Pro` intelligence. It has no repo or conversation
-context unless you provide it, so keep the prompt and file bundle focused.
+GPT model, with `Pro` intelligence. Supply the caller's context explicitly.
+Use a focused file bundle for local code; connected GitHub can provide remote
+repository context when available (see below).
 
 Request generated files only when needed; treat them as data and never execute
 them automatically:
@@ -87,6 +88,61 @@ 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
+account before sending any prompt or files. It defaults to normal ChatGPT for
+recovery; an explicit `--temporary` still requires Temporary Chat.
+
+If GitHub is disconnected or its connection cannot be confirmed, ask-pro opens
+GitHub's ChatGPT page and returns `connect_github_then_resume`. Install the
+plugin if needed, connect your account yourself, and review repository access.
+Select only the repositories you want available; an organization may require
+approval. Then run the emitted `--resume` command. It checks the connection again
+before submitting. ChatGPT login alone does not pass this GitHub check.
+
+Then explicitly request repository evidence in the prompt:
+
+```powershell
+ask-pro --github "Read owner/repo and explain its request authentication flow."
+```
+
+Use `--files` for local changes or a precise snapshot that GitHub cannot retrieve.
+For committed repository code, prefer `--github` with the repository, ref, paths,
+and question; source-file uploads are usually unnecessary when retrieval works.
+The flag requests read-only work and citations, but **does not enforce read-only
+GitHub permissions**. The live GitHub plugin advertises write capabilities;
+review the actual grant even though the [Help Center](https://help.openai.com/en/articles/11145903-connecting-github-to-chatgpt)
+describes a read-only app. [Allow read actions](https://help.openai.com/en/articles/20001495-managing-app-permissions-in-chatgpt)
+controls approval prompts, not the underlying access grant.
+
+A connected account does not prove access to a particular repository, revision,
+or Pro experience. ask-pro does not select an app in the composer, approve app
+actions, or verify the answer's sources. The opt-in [GitHub smoke](docs/manual-tests.md#connected-github-context)
+checks actual retrieval. GitHub authorization stays with ChatGPT; ask-pro needs
+no GitHub token.
+
 ## Development
 
 ```powershell

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

@@ -1,6 +1,9 @@
 #!/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";
 import { Command, Option } from "commander";
@@ -20,7 +23,16 @@ program
     .option("--prompt-file <path>", "read the question from a UTF-8 file; use - for stdin")
     .option("--artifacts", "ask Pro for ask-pro-response.zip plus markdown fallback")
     .option("--response-zip", "alias for --artifacts")
+    .addOption(new Option("--github", "use connected GitHub; pause for setup before sending").conflicts([
+    "resume",
+    "status",
+    "harvest",
+    "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")
@@ -45,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) });
@@ -108,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);
@@ -124,6 +144,8 @@ async function runAskPro(question, options) {
         return;
     }
     const dryRun = options.dryRun === true;
+    if (options.github && options.temporary === undefined)
+        options.temporary = false;
     const resolvedQuestion = await resolveQuestion(question, options, cwd);
     const artifacts = options.artifacts === true || options.responseZip === true;
     const session = await createAskProSession({
@@ -132,6 +154,7 @@ async function runAskPro(question, options) {
         filePatterns: options.files ?? [],
         dryRun,
         artifacts,
+        github: options.github,
     });
     const resumeCommand = buildResumeCommand(session.id, options, cwd);
     const harvestCommand = buildHarvestCommand(session.id, cwd);
@@ -182,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)),
@@ -190,19 +217,31 @@ 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") {
+        status.status === "NEEDS_USER_AUTH" ||
+        status.status === "NEEDS_GITHUB_CONNECTION") {
         try {
             await resumeAskProBrowserSession({
                 cwd,
                 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) {
-            if (error instanceof AssistantStoppedError) {
+            if (error instanceof GitHubConnectionRequiredError) {
+                const { status: paused } = await readAskProStatus({ cwd, sessionId });
+                printStatusRecord(paused);
+                return;
+            }
+            if (error instanceof AssistantStoppedError || error instanceof AssistantQuestionsError) {
                 const { status: stopped } = await readAskProStatus({ cwd, sessionId });
                 printStatusRecord(stopped, await readBrowserPreflight(cwd, stopped));
                 return;
@@ -234,7 +273,12 @@ async function submitOrResumeBrowserSession(cwd, sessionId, options) {
         });
     }
     catch (error) {
-        if (error instanceof AssistantStoppedError) {
+        if (error instanceof GitHubConnectionRequiredError) {
+            const { status: paused } = await readAskProStatus({ cwd, sessionId });
+            printStatusRecord(paused);
+            return;
+        }
+        if (error instanceof AssistantStoppedError || error instanceof AssistantQuestionsError) {
             const { status: stopped } = await readAskProStatus({ cwd, sessionId });
             printStatusRecord(stopped, await readBrowserPreflight(cwd, stopped));
             return;
@@ -320,6 +364,11 @@ function printStatusRecord(status, extra = {}) {
         state: normalizeState(status.status),
         reason: status.reason,
         temporary: normalizeTemporary(status.temporary),
+        github: status.github || undefined,
+        setup_url: status.status === "NEEDS_GITHUB_CONNECTION" ? GITHUB_SETUP_URL : undefined,
+        help: status.status === "NEEDS_GITHUB_CONNECTION"
+            ? "In the opened ChatGPT page, install GitHub if needed, connect your account, review repository access, then resume."
+            : undefined,
         action: actionForStatus(status),
         resume: shouldPrintResume(status) ? status.resumeCommand : undefined,
         harvest: shouldPrintHarvest(status) ? status.harvestCommand : undefined,
@@ -360,6 +409,10 @@ function actionForStatus(status) {
     if (status.reason === "stopped_without_answer")
         return "choose_resume_or_retry";
     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":
@@ -383,8 +436,10 @@ function shouldPrintResume(status) {
         "DRY_RUN_COMPLETE",
         "INCOMPLETE_ANSWER",
         "WAITING",
+        "AWAITING_ANSWERS",
         "READY_TO_SUBMIT",
         "NEEDS_USER_AUTH",
+        "NEEDS_GITHUB_CONNECTION",
         "WAIT_TIMED_OUT",
         "FAILED",
     ].includes(status.status);
@@ -402,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 {
@@ -428,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,9 @@ 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";
 import { closeTab } from "../browser/chromeLifecycle.js";
@@ -18,10 +21,11 @@ export async function runAskProBrowserSession(options) {
     const { dir } = getAskProSessionPaths(options.cwd, options.sessionId);
     return withSessionControllerLease(dir, () => runAskProBrowserSessionWithLease(options));
 }
-async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary, chatgptUrl: chatgptUrlOverride, browserProfileDir, agentId: agentIdOverride, allowStartMinimized = true, verbose, }) {
+async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary: requestedTemporary, chatgptUrl: chatgptUrlOverride, browserProfileDir, agentId: agentIdOverride, allowStartMinimized = true, verbose, }) {
     const paths = getAskProSessionPaths(cwd, sessionId);
     const prompt = await readAskProPrompt({ cwd, sessionId });
     const { status: sessionStatus } = await readAskProStatus({ cwd, sessionId });
+    const temporary = requestedTemporary ?? (sessionStatus.github ? false : undefined);
     const artifactsRequested = sessionStatus.artifacts === true;
     const agentId = agentIdOverride !== undefined ? agentIdOverride : resolveAskProAgentId();
     const browserProfile = browserProfileDir ?? (await ensureAskProBrowserProfileDir(agentId));
@@ -62,6 +66,7 @@ async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary, cha
                 },
             ],
             config: {
+                github: sessionStatus.github,
                 url: chatgptUrl,
                 manualLogin: true,
                 attachRunning: false,
@@ -163,7 +168,7 @@ async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary, cha
             temporary,
         })) {
             await appendAskProLog(cwd, sessionId, "Temporary Chat did not expose the Pro model; retrying in normal ChatGPT.");
-            await closeFallbackTemporaryTab(cwd, sessionId, logger);
+            await closeSessionBrowserTab(cwd, sessionId, logger);
             await updateAskProStatus({
                 cwd,
                 sessionId,
@@ -206,6 +211,16 @@ async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary, cha
                 verbose,
             });
         }
+        if (error instanceof GitHubConnectionRequiredError) {
+            await writeTerminalBrowserMetadata(cwd, sessionId, "needs_github_connection", error.reason);
+            await updateAskProStatus({
+                cwd,
+                sessionId,
+                status: "NEEDS_GITHUB_CONNECTION",
+                reason: error.reason,
+            });
+            throw error;
+        }
         if (isAuthGateError(error)) {
             const currentMetadata = await readBrowserMetadata(paths.browser).catch(() => ({}));
             await writeAskProBrowserMetadata({
@@ -232,6 +247,12 @@ async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary, cha
             });
             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({
@@ -268,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
@@ -282,6 +318,20 @@ async function resumeAskProBrowserSessionWithLease({ cwd, sessionId, temporary,
             ? ASK_PRO_CHATGPT_URL
             : (metadata.url ?? ASK_PRO_TEMPORARY_CHATGPT_URL);
     const fallbackProfile = await resolveResumeBrowserProfile(metadata);
+    if (sessionStatus.status === "NEEDS_GITHUB_CONNECTION" ||
+        (sessionStatus.github && metadata.runtime?.githubCheckPending === true)) {
+        await closeSessionBrowserTab(cwd, sessionId, logger);
+        await runAskProBrowserSessionWithLease({
+            cwd,
+            sessionId,
+            temporary: effectiveTemporary,
+            browserProfileDir: fallbackProfile,
+            agentId: metadata.agentId ?? null,
+            allowStartMinimized: false,
+            verbose,
+        });
+        return;
+    }
     let capturedFinalStatus = null;
     if (metadata.runtime) {
         metadata.runtime = normalizeResumeRuntime(metadata.runtime, metadata.profileDir, fallbackProfile);
@@ -350,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);
@@ -446,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({
@@ -467,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;
@@ -494,7 +555,7 @@ function withNoTemporaryResumeCommand(command) {
     }
     return withoutStrictTemporary.replace(/\s--resume(?=\s|$)/, " --no-temporary --resume");
 }
-async function closeFallbackTemporaryTab(cwd, sessionId, logger) {
+async function closeSessionBrowserTab(cwd, sessionId, logger) {
     const paths = getAskProSessionPaths(cwd, sessionId);
     const metadata = await readBrowserMetadata(paths.browser).catch(() => null);
     const runtime = metadata?.runtime;

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/ask-pro/session.js

@@ -20,7 +20,7 @@ const DEFAULT_EXCLUDES = [
 ];
 const SESSION_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,127}$/;
 const SESSION_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
-export async function createAskProSession({ cwd, question, filePatterns, dryRun, artifacts = false, }) {
+export async function createAskProSession({ cwd, question, filePatterns, dryRun, artifacts = false, github = false, }) {
     const trimmedQuestion = question.trim();
     if (!trimmedQuestion) {
         throw new Error("ask-pro requires a question.");
@@ -56,8 +56,9 @@ export async function createAskProSession({ cwd, question, filePatterns, dryRun,
         harvestCommand: `ask-pro --harvest ${sessionId}`,
         dryRun,
         artifacts,
+        ...(github ? { github: true } : {}),
     };
-    const submittedPrompt = renderSubmittedPrompt(question, artifacts);
+    const submittedPrompt = renderSubmittedPrompt(question, artifacts, github);
     const manifestMarkdown = renderManifestMarkdown(manifest);
     const browserMetadata = {
         schemaVersion: 1,
@@ -621,11 +622,11 @@ function redactSecretsForLog(message) {
     const findings = [];
     return redactSecrets(message, "log", findings);
 }
-function renderSubmittedPrompt(question, artifacts) {
+function renderSubmittedPrompt(question, artifacts, github) {
     const artifactRequest = artifacts
         ? "\nIf file generation is available, also create a downloadable zip named ask-pro-response.zip. It should contain IMPLEMENTATION_PLAN.md, TASKS.json, TEST_PLAN.md, RISK_REGISTER.md, FILES_TO_EDIT.md, and REPO_CONTEXT_USED.md. If you cannot create a zip, return the same content in markdown sections.\n"
         : "";
-    return `${question}
+    return `${question}${github ? "\n\nUse the connected GitHub app for the requested repository evidence. Keep the work read-only: do not change files, create issues or pull requests, or post comments. Cite the files and revision actually retrieved, and report missing access or revision conflicts." : ""}
 
 Read MANIFEST.md in CONTEXT.zip first. Treat the context files it lists as authoritative evidence only for the scope they cover, and call out material gaps or conflicts.
 ${artifactRequest}

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/github.js

@@ -0,0 +1,67 @@
+import { BrowserAutomationError } from "../errors.js";
+import { delay } from "../utils.js";
+const GITHUB_PLUGIN_ID = "plugin_connector_1p_1a69035c238881919c4190932b2df699";
+const GITHUB_APP_ID = "connector_76869538009648d5b282a4bb21c3d157";
+export const GITHUB_SETUP_URL = `https://chatgpt.com/plugins/${GITHUB_PLUGIN_ID}`;
+const GITHUB_SETTINGS_URL = `https://chatgpt.com/settings/plugins-settings/${GITHUB_PLUGIN_ID}/apps/${GITHUB_APP_ID}`;
+export class GitHubConnectionRequiredError extends BrowserAutomationError {
+    reason;
+    constructor(reason) {
+        super("Connect GitHub in the opened ChatGPT page, review repository access, then resume.", {
+            stage: "github-connection-required",
+        });
+        this.reason = reason;
+    }
+}
+// Read only visible connection controls, never account identifiers or OAuth state.
+function readGitHubConnectionState(accountSectionId) {
+    const visible = (element) => {
+        const rect = element.getBoundingClientRect();
+        const style = getComputedStyle(element);
+        return (rect.width > 0 && rect.height > 0 && style.display !== "none" && style.visibility !== "hidden");
+    };
+    const heading = Array.from(document.querySelectorAll("h1")).some((element) => visible(element) && element.textContent?.trim() === "GitHub");
+    if (!heading)
+        return "unknown";
+    const section = document.getElementById(accountSectionId);
+    if (!section || !visible(section))
+        return "unknown";
+    const buttons = Array.from(section.querySelectorAll("button")).filter(visible);
+    if (buttons.some((button) => /^reconnect\b/i.test(button.textContent?.trim() ?? ""))) {
+        return "disconnected";
+    }
+    if (buttons.some((button) => button.getAttribute("aria-label")?.startsWith("Actions for "))) {
+        return "connected";
+    }
+    return buttons.some((button) => /^connect\b/i.test(button.textContent?.trim() ?? ""))
+        ? "disconnected"
+        : "unknown";
+}
+export async function ensureGitHubConnection(Page, Runtime, logger, timeoutMs) {
+    const { result: location } = await Runtime.evaluate({
+        expression: "location.href",
+        returnByValue: true,
+    });
+    const returnUrl = location.value;
+    await Page.navigate({ url: GITHUB_SETTINGS_URL });
+    const deadline = Date.now() + timeoutMs;
+    let state = "unknown";
+    do {
+        const result = await Runtime.evaluate({
+            expression: `(${readGitHubConnectionState.toString()})(${JSON.stringify(`plugin-connected-accounts-${GITHUB_APP_ID}`)})`,
+            returnByValue: true,
+        }).catch(() => undefined);
+        state = result?.result.value ?? "unknown";
+        if (state !== "unknown")
+            break;
+        if (Date.now() < deadline)
+            await delay(300);
+    } while (Date.now() < deadline);
+    if (state !== "connected") {
+        // Stop on ChatGPT before the human starts OAuth; do not observe consent or callback URLs.
+        await Page.navigate({ url: GITHUB_SETUP_URL });
+        throw new GitHubConnectionRequiredError(state === "disconnected" ? "github_connection_required" : "github_connection_unverified");
+    }
+    logger("GitHub connected. Repository access depends on the selected repositories.");
+    await Page.navigate({ url: returnUrl });
+}

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/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

@@ -10,6 +10,7 @@ import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked,
 import { INPUT_SELECTORS } from "./constants.js";
 import { uploadAttachmentViaDataTransfer } from "./actions/remoteFileTransfer.js";
 import { ensureThinkingTime } from "./actions/thinkingTime.js";
+import { ensureGitHubConnection, GitHubConnectionRequiredError } from "./actions/github.js";
 import { startThinkingStatusMonitor } from "./actions/thinkingStatus.js";
 import { createAssistantContinuation } from "./actions/assistantResponse.js";
 import { createPostSubmitInputGuard } from "./actions/inputGuard.js";
@@ -18,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";
@@ -278,9 +280,10 @@ export async function runBrowserMode(options) {
         logger.sessionLog = options.log.sessionLog;
     }
     const runtimeHintCb = options.runtimeHintCb;
+    let githubCheckPending = config.github;
     let lastTargetId;
     let lastUrl;
-    const emitRuntimeHint = async () => {
+    const emitRuntimeHint = async (required = false) => {
         if (!runtimeHintCb || !chrome?.port) {
             return;
         }
@@ -294,11 +297,14 @@ export async function runBrowserMode(options) {
             conversationId,
             userDataDir,
             controllerPid: process.pid,
+            githubCheckPending,
         };
         try {
             await runtimeHintCb(hint);
         }
         catch (error) {
+            if (required)
+                throw error;
             const message = error instanceof Error ? error.message : String(error);
             logger(`Failed to persist runtime hint: ${message}`);
         }
@@ -517,6 +523,7 @@ export async function runBrowserMode(options) {
                     });
                     client = connection.client;
                     isolatedTargetId = connection.targetId ?? null;
+                    lastTargetId = connection.targetId ?? undefined;
                     if (!isolatedTargetId) {
                         launchTargetIds = [];
                     }
@@ -702,6 +709,12 @@ export async function runBrowserMode(options) {
         }));
         if (manualLogin)
             manualLoginRecoveryInProgress = false;
+        if (config.github) {
+            await raceWithDisconnect(ensureGitHubConnection(Page, Runtime, logger, config.inputTimeoutMs));
+            githubCheckPending = false;
+            // Persist this before upload/send so a failed save cannot cause a duplicate retry.
+            await emitRuntimeHint(true);
+        }
         if (config.url !== baseUrl) {
             await raceWithDisconnect(navigateToPromptReadyWithFallback(Page, Runtime, {
                 url: config.url,
@@ -1280,6 +1293,18 @@ 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");
+            await emitRuntimeHint();
+            throw normalizedError;
+        }
         if (manualLoginRecoveryInProgress && isWebSocketClosureError(normalizedError)) {
             const livePort = await readDevToolsPort(userDataDir);
             const endpoint = livePort
@@ -1358,6 +1383,9 @@ export async function runBrowserMode(options) {
                     isolatedTargetId = recovered.ownsTarget ? recovered.targetId : null;
                     ownsTarget = recovered.ownsTarget;
                     connectionClosedUnexpectedly = false;
+                    // The restarted run owns persistence; the outer hook would save stale onboarding state.
+                    removeTerminationHooks?.();
+                    removeTerminationHooks = null;
                     const restartedResult = await runBrowserMode(config.browserTabRef
                         ? {
                             ...options,
@@ -1771,9 +1799,11 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     let expectedConversationUrl;
     let expectedConversationId;
     let attachedExistingTab = false;
+    let githubCheckPending = config.github;
+    let githubSetupRequired = false;
     let ownsTarget = true;
     const runtimeHintCb = options.runtimeHintCb;
-    const emitRuntimeHint = async () => {
+    const emitRuntimeHint = async (required = false) => {
         if (!runtimeHintCb)
             return;
         try {
@@ -1787,9 +1817,12 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
                 tabUrl: lastUrl,
                 conversationId,
                 controllerPid: process.pid,
+                githubCheckPending,
             });
         }
         catch (error) {
+            if (required)
+                throw error;
             const message = error instanceof Error ? error.message : String(error);
             logger(`Failed to persist runtime hint: ${message}`);
         }
@@ -1924,6 +1957,12 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             await raceWithDisconnect(ensureLoggedIn(Runtime, logger, { remoteSession: true }));
             await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
         }
+        if (config.github) {
+            await raceWithDisconnect(ensureGitHubConnection(Page, Runtime, logger, config.inputTimeoutMs));
+            githubCheckPending = false;
+            await emitRuntimeHint(true);
+            await raceWithDisconnect(ensurePromptReady(Runtime, config.inputTimeoutMs, logger));
+        }
         logger(`Prompt textarea ready (initial focus, ${promptText.length.toLocaleString()} chars queued)`);
         try {
             const { result } = await Runtime.evaluate({
@@ -2312,6 +2351,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
     }
     catch (error) {
         const normalizedError = error instanceof Error ? error : new Error(String(error));
+        githubSetupRequired = normalizedError instanceof GitHubConnectionRequiredError;
         const socketClosed = connectionClosedUnexpectedly || isWebSocketClosureError(normalizedError);
         connectionClosedUnexpectedly = connectionClosedUnexpectedly || socketClosed;
         if (!socketClosed) {
@@ -2344,7 +2384,7 @@ async function runRemoteBrowserMode(promptText, attachments, config, logger, opt
             // ignore
         }
         removeDialogHandler?.();
-        if (ownsTarget) {
+        if (ownsTarget && !githubSetupRequired) {
             await closeRemoteChromeTarget(host, port, remoteTargetId ?? undefined, logger);
         }
         // Don't kill remote Chrome - it's not ours to manage

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.53",
+  "version": "0.1.61",
   "description": "Browser-backed ChatGPT Pro escalation for hard engineering questions.",
   "keywords": [
     "agents",

package/skills/ask-pro/SKILL.md

@@ -34,10 +34,13 @@ When invoked:
 
 1. Inspect the repo and the relevant files.
 2. Identify the exact decision Pro should answer.
-3. Choose a small, high-signal file bundle with `--files`.
+3. For committed code on GitHub, prefer `--github` and give Pro the repository,
+   ref, relevant paths, and question. Let it retrieve the code instead of assembling
+   a source bundle. Add a small `--files` bundle only for uncommitted changes,
+   local-only evidence, or repository content the connection cannot access.
 4. Write the prompt yourself using the Prompt Shape below.
-5. Run the smallest useful command, usually
-   `ask-pro --no-temporary --files "<glob>" "<prompt>"` for repo advisories.
+5. Run the smallest useful command: `ask-pro --github "<prompt>"` for GitHub
+   evidence, or `ask-pro --no-temporary --files "<glob>" "<prompt>"` for a file bundle.
    For multiline prompts, write a temporary prompt file and use
    `ask-pro --no-temporary --prompt-file <path> --files "<glob>"`; do not rely
    on shell multiline quoting.
@@ -88,7 +91,7 @@ again. Example:
 
 ## Prompt Shape
 
-Assume Pro has no caller or repository context. Include each material fact and
+Assume Pro has no caller context or local checkout. Include each material fact and
 instruction once: the goal, current state, hard constraints, evidence, success
 criteria, and required output. Do not rely on the agent's conversation context, repo
 folklore, prior ask-pro runs, branch names, or unstated user preferences.
@@ -113,12 +116,62 @@ Keep bundles focused: source files under review, focused tests, relevant docs,
 known recent changes, and validation status. Avoid whole-repo bundles unless the
 question is explicitly architectural.
 
+## Connected GitHub (optional)
+
+Prefer `--github` for remote repository evidence. It checks
+the connection before uploading or submitting, and defaults to normal ChatGPT.
+Do not require GitHub for file-based consults. Availability varies by account,
+workspace, model, and ChatGPT experience.
+
+If the CLI returns `needs_github_connection` / `connect_github_then_resume`,
+direct the human to the opened GitHub page in ask-pro's browser. They install the
+plugin if needed, complete sign-in, review permissions, and select repositories;
+organization approval may be needed. Wait for them to finish, then run the
+emitted resume command without adding `--github`. The requirement is saved with
+the session and checked again. Do not start a second session or submit through
+the browser yourself. Never collect GitHub credentials or automate authorization.
+
+If available, GitHub's **Allow read actions** permission can avoid read approval
+prompts. The human chooses that setting. It controls approval behavior, not the
+underlying permissions of a write-capable app; see
+[app permissions](https://help.openai.com/en/articles/20001495-managing-app-permissions-in-chatgpt).
+The live GitHub plugin advertises write capabilities despite the Help Center's
+read-only description. `--github` requests read-only work; it does not restrict
+the provider's permissions or prove that writes are impossible.
+
+If GitHub is already connected, proceed without a setup question or source-file
+bundle. For the consult, name the repository (`owner/repo`), relevant paths, and
+requested branch or commit in the prompt. Explicitly ask Pro
+to answer the specific question. The wrapper requests the connected GitHub app,
+read-only work, citations, the revision inspected, and access gaps. Do not
+infer repository access from ChatGPT login or a successful CLI exit.
+
+Keep `--files` for local/uncommitted changes, non-GitHub evidence, and snapshots
+that the app cannot retrieve. Distinguish
+uploaded evidence from GitHub evidence, and ask Pro to flag revision conflicts.
+If the app or requested revision is unavailable, offer a new consult with a
+focused file bundle and
+disclose that limitation. Do not silently switch away from Pro. The CLI submits
+text; it does not select an app in the composer or handle app approval prompts.
+Until a live run demonstrates retrieval, describe this as an available setup
+path, not a verified connection. Confirm material claims against the repo.
+
 ## Output
 
 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.
@@ -148,6 +201,7 @@ state is `INCOMPLETE_ANSWER` / `preamble_without_artifacts`, do not treat
 ```bash
 ask-pro "Review the async billing webhook migration plan and return an implementation plan."
 ask-pro --no-temporary --prompt-file question.md --files src --files tests
+ask-pro --github "In owner/repo at <commit>, inspect src/auth and explain token validation."
 ask-pro --temporary "Review this sensitive migration plan, and fail if Temporary Chat cannot use Pro."
 ask-pro --no-temporary "Review this in normal ChatGPT instead of Temporary Chat."
 ask-pro --prompt-file question.md --files .\src