ask-pro 0.1.51 → 0.1.58

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
 
@@ -71,8 +71,10 @@ Ask for a recoverable repo consult:
 ask-pro --no-temporary --prompt-file question.md --files src --files tests
 ```
 
-ask-pro selects `Latest` with `Pro` intelligence. It has no repo or conversation
-context unless you provide it, so keep the prompt and file bundle focused.
+ask-pro selects `Latest` when available, otherwise the highest numbered available
+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:
@@ -86,6 +88,40 @@ 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.
 
+## 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,7 @@
 #!/usr/bin/env node
 import "dotenv/config";
 import { AssistantStoppedError } from "../src/browser/errors.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,6 +21,12 @@ 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")
     .option("--status [session-id]", "show ask-pro session status")
     .option("--harvest [session-id]", "print harvested ANSWER.md for a session")
@@ -124,6 +131,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 +141,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);
@@ -192,7 +202,8 @@ async function submitOrResumeBrowserSession(cwd, sessionId, options) {
     if (status.status === "WAITING" ||
         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,
@@ -202,6 +213,11 @@ async function submitOrResumeBrowserSession(cwd, sessionId, options) {
             });
         }
         catch (error) {
+            if (error instanceof GitHubConnectionRequiredError) {
+                const { status: paused } = await readAskProStatus({ cwd, sessionId });
+                printStatusRecord(paused);
+                return;
+            }
             if (error instanceof AssistantStoppedError) {
                 const { status: stopped } = await readAskProStatus({ cwd, sessionId });
                 printStatusRecord(stopped, await readBrowserPreflight(cwd, stopped));
@@ -234,6 +250,11 @@ async function submitOrResumeBrowserSession(cwd, sessionId, options) {
         });
     }
     catch (error) {
+        if (error instanceof GitHubConnectionRequiredError) {
+            const { status: paused } = await readAskProStatus({ cwd, sessionId });
+            printStatusRecord(paused);
+            return;
+        }
         if (error instanceof AssistantStoppedError) {
             const { status: stopped } = await readAskProStatus({ cwd, sessionId });
             printStatusRecord(stopped, await readBrowserPreflight(cwd, stopped));
@@ -320,6 +341,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 +386,8 @@ 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 "DRY_RUN_COMPLETE":
         case "INCOMPLETE_ANSWER":
         case "READY_TO_SUBMIT":
@@ -385,6 +413,7 @@ function shouldPrintResume(status) {
         "WAITING",
         "READY_TO_SUBMIT",
         "NEEDS_USER_AUTH",
+        "NEEDS_GITHUB_CONNECTION",
         "WAIT_TIMED_OUT",
         "FAILED",
     ].includes(status.status);

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

@@ -2,6 +2,7 @@ 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 { 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 +19,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 +64,7 @@ async function runAskProBrowserSessionWithLease({ cwd, sessionId, temporary, cha
                 },
             ],
             config: {
+                github: sessionStatus.github,
                 url: chatgptUrl,
                 manualLogin: true,
                 attachRunning: false,
@@ -163,7 +166,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 +209,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({
@@ -282,6 +295,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);
@@ -494,7 +521,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/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/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/modelSelection.js

@@ -269,7 +269,7 @@ function buildModelSelectionExpression(targetModel, strategy) {
       return { status: 'already-selected', label };
     }
     const buttonMatchesTarget = () => {
-      // The numbered pill cannot prove that the rolling Latest option is selected.
+      // The composer pill cannot prove that the newest available model is selected.
       if (normalizedTarget === 'latest') return false;
       const normalizedLabel = normalize(getButtonLabel());
       if (!normalizedLabel) return false;
@@ -446,14 +446,24 @@ function buildModelSelectionExpression(targetModel, strategy) {
             testid.toLowerCase().includes('submenu') ||
             option.getAttribute('data-has-submenu') !== null ||
             option.getAttribute('aria-haspopup') === 'menu';
-          const baseScore = scoreOption(normalizedText, testid);
+          if (normalizedTarget === 'latest') {
+            const rect = option.getBoundingClientRect();
+            if (isSubmenu || rect.width <= 0 || rect.height <= 0 ||
+                option.getAttribute('aria-disabled') === 'true' || option.hasAttribute('disabled')) continue;
+          }
+          // Read the raw label: normalization removes decimal separators.
+          const modelVersion = normalizedTarget === 'latest'
+            ? text.trim().match(/^gpt[-\\s]+(\\d+(?:\\.\\d+)*)(?![.\\d])/i)?.[1] ?? ''
+            : '';
+          const baseScore = modelVersion ? 500 : scoreOption(normalizedText, testid);
           if (baseScore <= 0) {
             continue;
           }
           const score = baseScore + (isSubmenu ? 0 : 1);
           const label = getOptionLabel(option);
-          if (!bestMatch || score > bestMatch.score) {
-            bestMatch = { node: option, label, score, testid, normalizedText, isSubmenu };
+          if (!bestMatch || score > bestMatch.score ||
+              (score === bestMatch.score && modelVersion.localeCompare(bestMatch.modelVersion, 'en', { numeric: true }) > 0)) {
+            bestMatch = { node: option, label, score, testid, normalizedText, isSubmenu, modelVersion };
           }
         }
       }

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";
@@ -278,9 +279,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 +296,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 +522,7 @@ export async function runBrowserMode(options) {
                     });
                     client = connection.client;
                     isolatedTargetId = connection.targetId ?? null;
+                    lastTargetId = connection.targetId ?? undefined;
                     if (!isolatedTargetId) {
                         launchTargetIds = [];
                     }
@@ -702,6 +708,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 +1292,12 @@ export async function runBrowserMode(options) {
     }
     catch (error) {
         let normalizedError = error instanceof Error ? error : new Error(String(error));
+        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 +1376,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 +1792,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 +1810,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 +1950,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 +2344,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 +2377,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ask-pro",
-  "version": "0.1.51",
+  "version": "0.1.58",
   "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.
@@ -58,7 +61,8 @@ When invoked:
    `harvest` command when that is the next action.
 8. Treat the answer as advisory; turn it into your own plan before editing code.
 
-`ask-pro` selects `Latest`, then `Pro` intelligence. Do not require a
+`ask-pro` selects `Latest` when available, otherwise the highest numbered available
+GPT model, then `Pro` intelligence. Do not require a
 different dated model label or a separate thinking-effort control in the prompt
 or workflow.
 
@@ -87,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.
@@ -112,6 +116,46 @@ 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`,
@@ -147,6 +191,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