@doist/doistbot-cli 1.0.6 → 1.0.8

package/dist/actions/auth.js

@@ -1,3 +1,4 @@
+import chalk from 'chalk';
 import { deleteGeminiApiKey, deleteOpenRouterApiKey, getAuthStatus, loginOpenAICodex, logoutOpenAICodex, saveGeminiApiKey, saveOpenRouterApiKey, } from '../auth.js';
 import { getEnvApiKeys } from '../env.js';
 import { FILE_STORE_PATH } from '../file-store.js';
@@ -43,6 +44,18 @@ const AUTH_LOGOUT_PROVIDER_CONFIGS = [
 ];
 const AUTH_LOGOUT_PROVIDERS = AUTH_LOGOUT_PROVIDER_CONFIGS.map(({ value }) => value);
 export const AUTH_LOGOUT_PROVIDER_USAGE = `${AUTH_LOGOUT_PROVIDERS.join('|')}|all`;
+const OPTIONAL_LABEL = '(optional)';
+const SKIP_INSTRUCTION = 'press Enter to skip';
+const API_KEY_PROMPT = 'Paste your API Key: ';
+function highlightOptionalText(value) {
+    return chalk.bold.yellow(value);
+}
+function formatOptionalLabel() {
+    return highlightOptionalText(OPTIONAL_LABEL);
+}
+function formatSkipInstruction() {
+    return highlightOptionalText(SKIP_INSTRUCTION);
+}
 export async function runAuthSetup(dependencies = {}) {
     const deps = {
         getAuthStatus,
@@ -57,19 +70,22 @@ export async function runAuthSetup(dependencies = {}) {
     const status = await deps.getAuthStatus();
     deps.writeLine('1. OpenAI Codex');
     deps.writeLine();
-    if (status.openai.configured) {
+    if (status.openai.configured && !status.openai.refreshFailed) {
         deps.writeLine('✓ OpenAI already configured (pi-auth).');
     }
     else {
         if (!deps.isInteractive) {
             throw new Error('Cannot configure OpenAI Codex auth in non-interactive mode.');
         }
+        if (status.openai.refreshFailed) {
+            deps.writeLine('OpenAI session could not be refreshed (expired, revoked, or offline). Reconnecting.');
+        }
         await deps.loginOpenAICodex();
         deps.writeLine();
         deps.writeLine('✓ OpenAI configured.');
     }
     deps.writeLine();
-    deps.writeLine('2. Gemini API key');
+    deps.writeLine(`2. Gemini API key ${formatOptionalLabel()}`);
     deps.writeLine();
     if (status.gemini.source === 'env') {
         deps.writeLine('✓ Gemini already configured from GEMINI_API_KEY.');
@@ -85,8 +101,8 @@ export async function runAuthSetup(dependencies = {}) {
             deps.writeLine('Gemini not configured. Skipping optional Gemini provider.');
         }
         else {
-            deps.writeLine('Doistbot can use Gemini via Google Vertex. Paste a Gemini API key, or press Enter to skip.');
-            const geminiApiKey = (await deps.promptHiddenInput('Gemini API key (optional): ')).trim();
+            deps.writeLine(`Doistbot can use Gemini via Google Vertex. Paste a Gemini API key, or ${formatSkipInstruction()}.`);
+            const geminiApiKey = (await deps.promptHiddenInput(API_KEY_PROMPT)).trim();
             if (!geminiApiKey) {
                 deps.writeLine();
                 deps.writeLine('Gemini skipped. You can add it later with `doistbot auth`.');
@@ -102,7 +118,7 @@ export async function runAuthSetup(dependencies = {}) {
         }
     }
     deps.writeLine();
-    deps.writeLine('3. OpenRouter API key');
+    deps.writeLine(`3. OpenRouter API key ${formatOptionalLabel()}`);
     deps.writeLine();
     if (status.openrouter.source === 'env') {
         deps.writeLine('✓ OpenRouter already configured from OPENROUTER_API_KEY.');
@@ -117,10 +133,17 @@ export async function runAuthSetup(dependencies = {}) {
         return;
     }
     if (!deps.isInteractive) {
-        throw new Error('Cannot prompt for OpenRouter API key in non-interactive mode. Set OPENROUTER_API_KEY instead.');
+        deps.writeLine('OpenRouter not configured. Skipping optional OpenRouter provider.');
+        return;
     }
-    deps.writeLine('Doistbot uses OpenRouter for DeepSeek, Z.ai, and other non-GPT review models. Please create an OpenRouter API key at https://openrouter.ai/keys and paste it here. (Use your Work Perk for it)');
-    const backend = await deps.saveOpenRouterApiKey(await deps.promptHiddenInput('OpenRouter API key: '));
+    deps.writeLine(`Doistbot can use OpenRouter for DeepSeek, Z.ai, and other open models. Paste an OpenRouter API key, or ${formatSkipInstruction()}.`);
+    const openRouterApiKey = (await deps.promptHiddenInput(API_KEY_PROMPT)).trim();
+    if (!openRouterApiKey) {
+        deps.writeLine();
+        deps.writeLine('OpenRouter skipped. You can add it later with `doistbot auth`.');
+        return;
+    }
+    const backend = await deps.saveOpenRouterApiKey(openRouterApiKey);
     deps.writeLine();
     if (backend === 'file') {
         deps.writeLine(`Note: ${getSecureStoreLabel()} unavailable; key stored in ${FILE_STORE_PATH} with 0600 permissions.`);
@@ -129,9 +152,18 @@ export async function runAuthSetup(dependencies = {}) {
 }
 export async function runAuthStatus() {
     const status = await getAuthStatus();
-    writeLine(`OpenAI: ${status.openai.configured ? `configured (${status.openai.source ?? 'unknown'})` : 'not configured'}`);
-    writeLine(`Gemini (optional): ${status.gemini.configured ? `configured (${status.gemini.source ?? 'unknown'})` : 'not configured'}`);
-    writeLine(`OpenRouter: ${status.openrouter.configured ? `configured (${status.openrouter.source ?? 'unknown'})` : 'not configured'}`);
+    writeLine(`OpenAI: ${formatOpenAIStatus(status.openai)}`);
+    writeLine(`Gemini ${formatOptionalLabel()}: ${status.gemini.configured ? `configured (${status.gemini.source ?? 'unknown'})` : 'not configured'}`);
+    writeLine(`OpenRouter ${formatOptionalLabel()}: ${status.openrouter.configured ? `configured (${status.openrouter.source ?? 'unknown'})` : 'not configured'}`);
+}
+function formatOpenAIStatus(status) {
+    if (!status.configured) {
+        return 'not configured';
+    }
+    const base = `configured (${status.source ?? 'unknown'})`;
+    return status.refreshFailed
+        ? `${base} — session could not be refreshed; check your connection or run \`doistbot auth login\``
+        : base;
 }
 export async function runAuthLogout(target, dependencies = {}) {
     const deps = {

package/dist/actions/doctor.js

@@ -4,12 +4,14 @@ import { checkGit, checkPiDependency, checkRepository, checkSandboxBuild } from
 import { renderDiagnosticCheck } from '../terminal.js';
 export function getConfiguredProviders({ status, }) {
     return [
-        status.openai.configured ? `OpenAI (${status.openai.source ?? 'configured'})` : undefined,
+        status.openai.configured && !status.openai.refreshFailed
+            ? `OpenAI (${status.openai.source ?? 'configured'})`
+            : undefined,
         status.gemini.configured
             ? `Gemini optional (${status.gemini.source ?? 'configured'})`
             : undefined,
         status.openrouter.configured
-            ? `OpenRouter (${status.openrouter.source ?? 'configured'})`
+            ? `OpenRouter optional (${status.openrouter.source ?? 'configured'})`
             : undefined,
     ].filter((provider) => provider !== undefined);
 }

package/dist/actions/review.js

@@ -1,4 +1,4 @@
-import { formatMissingRequiredCliAuthProviders, getApiKeys, getMissingRequiredCliReviewAuthProviders, } from '../config.js';
+import { formatMissingRequiredCliAuthProviders, getApiKeys, getCliReviewRouting, getMissingRequiredCliReviewAuthProviders, } from '../config.js';
 import { getRepositoryRoot, loadSandboxFormatModule, loadSandboxReviewModule } from '../runtime.js';
 import { formatReviewProgress, renderAlert, renderMarkdown, withSpinner, writeLine, } from '../terminal.js';
 const LOCAL_REVIEW_SOURCE_STAGED = 'staged';
@@ -21,10 +21,14 @@ function getReadableProviderFailure(failure) {
     if (failure.model === 'openai' &&
         (normalized.includes('no api key found for openai') ||
             normalized.includes('no api key found for openai-codex') ||
+            normalized.includes('no api key for provider') ||
             normalized.includes('use /login') ||
             normalized.includes('invalid api key') ||
-            normalized.includes('incorrect api key'))) {
-        return 'OpenAI Codex is not authenticated. Run `doistbot auth` to reconnect OpenAI.';
+            normalized.includes('incorrect api key') ||
+            normalized.includes('refresh_token_invalidated') ||
+            normalized.includes('unauthorized') ||
+            /\b401\b/.test(normalized))) {
+        return 'OpenAI Codex is not authenticated. Run `doistbot auth login` to reconnect OpenAI.';
     }
     if (failure.model === 'gemini' &&
         (normalized.includes('429') ||
@@ -40,7 +44,8 @@ function getReadableProviderFailure(failure) {
             normalized.includes('invalid_argument') ||
             normalized.includes('invalid api key') ||
             normalized.includes('no api key found for google') ||
-            normalized.includes('no api key found for gemini'))) {
+            normalized.includes('no api key found for gemini') ||
+            normalized.includes('no api key for provider'))) {
         return 'Gemini API key is invalid or missing. Run `doistbot auth` and paste a valid Gemini key.';
     }
     const firstLine = error
@@ -205,16 +210,7 @@ function getMissingAuthProviderFailures(missingProviders) {
     if (missingProviders.includes('OpenAI')) {
         failures.push({
             model: 'openai',
-            message: 'OpenAI not configured; run `doistbot auth`',
-        });
-    }
-    if (missingProviders.includes('OpenRouter')) {
-        failures.push({
-            model: 'deepseek',
-            message: 'OpenRouter not configured; run `doistbot auth`',
-        }, {
-            model: 'zai',
-            message: 'OpenRouter not configured; run `doistbot auth`',
+            message: 'OpenAI authentication unavailable; run `doistbot auth login`',
         });
     }
     return failures;
@@ -245,6 +241,7 @@ async function runLocalReviewForCli({ source, apiKeys, onProgress, }) {
         workspaceDir: getRepositoryRoot(),
         source,
         apiKeys,
+        ...getCliReviewRouting(apiKeys),
         suppressLogs: true,
         onProgress,
     });

package/dist/auth.js

@@ -28,9 +28,22 @@ export function getBrowserOpenCommand(platform, url) {
     }
     return { command: 'xdg-open', args: [url] };
 }
-export async function hasOpenAICodexAuth(storage) {
+/**
+ * Check that the stored OAuth session is usable, not just present.
+ * getApiKey returns the cached access token when unexpired; when expired it
+ * attempts one cross-process-locked refresh, persists the result, and returns
+ * undefined when the refresh fails (revoked session, no network) while
+ * preserving the stored credentials. Unexpected storage errors propagate.
+ */
+export async function getOpenAICodexAuthState(storage) {
     const resolvedStorage = storage ?? (await createPiAuthStorage());
-    return resolvedStorage.get(OPENAI_CODEX_PROVIDER_ID)?.type === 'oauth';
+    if (resolvedStorage.get(OPENAI_CODEX_PROVIDER_ID)?.type !== 'oauth') {
+        return 'missing';
+    }
+    const apiKey = await resolvedStorage.getApiKey(OPENAI_CODEX_PROVIDER_ID, {
+        includeFallback: false,
+    });
+    return apiKey ? 'ready' : 'refresh-failed';
 }
 export async function loginOpenAICodex(storage) {
     const resolvedStorage = storage ?? (await createPiAuthStorage());
@@ -105,11 +118,15 @@ export async function getAuthStatus({ env = process.env, storage, geminiStore =
     const openRouterStored = envApiKeys.openrouter
         ? { value: undefined }
         : await readStoredOpenRouterApiKey(openRouterStore).catch(() => ({ value: undefined }));
-    const openAICodexAuthConfigured = await hasOpenAICodexAuth(storage);
+    const openAICodexAuthState = await getOpenAICodexAuthState(storage);
     return {
-        openai: openAICodexAuthConfigured
-            ? { configured: true, source: 'pi-auth' }
-            : { configured: false, source: undefined },
+        openai: openAICodexAuthState === 'missing'
+            ? { configured: false, source: undefined }
+            : {
+                configured: true,
+                source: 'pi-auth',
+                refreshFailed: openAICodexAuthState === 'refresh-failed',
+            },
         gemini: envApiKeys.gemini
             ? { configured: true, source: 'env' }
             : {

package/dist/config.js

@@ -1,13 +1,35 @@
-import { getStoredGeminiApiKey, getStoredOpenRouterApiKey, hasOpenAICodexAuth, PI_AUTH_API_KEY, } from './auth.js';
+import { getOpenAICodexAuthState, getStoredGeminiApiKey, getStoredOpenRouterApiKey, PI_AUTH_API_KEY, } from './auth.js';
 import { getEnvApiKeys } from './env.js';
-const REQUIRED_CLI_AUTH_PROVIDERS = [
-    { provider: 'openai', label: 'OpenAI' },
-    { provider: 'openrouter', label: 'OpenRouter' },
+const REQUIRED_CLI_AUTH_PROVIDERS = [{ provider: 'openai', label: 'OpenAI' }];
+const ALL_REVIEW_FOCUSES = [
+    'general',
+    'quality',
+    'efficiency',
+    'tests',
+    'standards',
 ];
+const OPENROUTER_REVIEW_MODELS = ['deepseek', 'zai'];
+const CLI_GEMINI_REVIEW_MODEL = 'gemini-3.5-flash';
+function createCliGeminiCredential(apiKey) {
+    return {
+        apiKey,
+        modelName: CLI_GEMINI_REVIEW_MODEL,
+    };
+}
+function createCliGeminiSummaryModel(credential) {
+    if (!credential) {
+        return undefined;
+    }
+    return {
+        provider: 'gemini',
+        credential,
+        modelName: CLI_GEMINI_REVIEW_MODEL,
+    };
+}
 export async function getApiKeys(env = process.env, auth = {
     getStoredGeminiApiKey,
     getStoredOpenRouterApiKey,
-    hasOpenAICodexAuth,
+    getOpenAICodexAuthState,
 }) {
     const envApiKeys = getEnvApiKeys(env);
     const storedGeminiApiKey = envApiKeys.gemini
@@ -16,36 +38,60 @@ export async function getApiKeys(env = process.env, auth = {
     const storedOpenRouterApiKey = envApiKeys.openrouter
         ? undefined
         : await auth.getStoredOpenRouterApiKey().catch(() => undefined);
-    const openAICodexAuthConfigured = await auth.hasOpenAICodexAuth();
+    const openAICodexAuthState = await auth.getOpenAICodexAuthState();
     const openRouterApiKey = envApiKeys.openrouter || storedOpenRouterApiKey;
     const apiKeys = {};
     const geminiApiKey = envApiKeys.gemini || storedGeminiApiKey;
     if (geminiApiKey) {
-        apiKeys.gemini = geminiApiKey;
+        apiKeys.gemini = createCliGeminiCredential(geminiApiKey);
     }
     if (openRouterApiKey) {
         apiKeys.deepseek = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
         apiKeys.zai = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
     }
-    if (openAICodexAuthConfigured) {
+    if (openAICodexAuthState === 'ready') {
         apiKeys.openai = PI_AUTH_API_KEY;
     }
     return apiKeys;
 }
 export function getMissingRequiredCliAuthProviders(status) {
-    return REQUIRED_CLI_AUTH_PROVIDERS.filter(({ provider }) => !status[provider].configured).map(({ label }) => label);
+    return REQUIRED_CLI_AUTH_PROVIDERS.filter(({ provider }) => {
+        const providerStatus = status[provider];
+        return !providerStatus.configured || providerStatus.refreshFailed === true;
+    }).map(({ label }) => label);
 }
 export function getMissingRequiredCliReviewAuthProviders(apiKeys) {
     return REQUIRED_CLI_AUTH_PROVIDERS.filter(({ provider }) => {
         switch (provider) {
             case 'openai':
                 return !apiKeys.openai;
-            case 'openrouter':
-                return !(apiKeys.deepseek && apiKeys.zai);
         }
         return false;
     }).map(({ label }) => label);
 }
 export function formatMissingRequiredCliAuthProviders(missingProviders) {
-    return `${missingProviders.join(' and ')} not configured; run \`doistbot auth\``;
+    return `${missingProviders.join(' and ')} authentication unavailable (not configured, or the session could not be refreshed); run \`doistbot auth login\``;
+}
+export function getCliReviewRouting(apiKeys) {
+    const hasGemini = Boolean(apiKeys.gemini);
+    const hasOpenRouter = Boolean(apiKeys.deepseek && apiKeys.zai);
+    if (hasGemini && hasOpenRouter) {
+        return {
+            reviewModelsEnabled: ['openai', ...OPENROUTER_REVIEW_MODELS],
+            geminiFallbackFocuses: ALL_REVIEW_FOCUSES,
+        };
+    }
+    const focusModels = [
+        'openai',
+        ...(hasGemini ? ['gemini'] : []),
+        ...(hasOpenRouter ? OPENROUTER_REVIEW_MODELS : []),
+    ];
+    return {
+        reviewModelsEnabled: focusModels,
+        reviewModelsByFocus: Object.fromEntries(ALL_REVIEW_FOCUSES.map((focus) => [focus, focusModels])),
+        geminiFallbackFocuses: [],
+        ...(hasGemini && !hasOpenRouter
+            ? { reviewSummaryModel: createCliGeminiSummaryModel(apiKeys.gemini) }
+            : {}),
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/doistbot-cli",
-    "version": "1.0.6",
+    "version": "1.0.8",
     "description": "Local self-review CLI for Doistbot",
     "type": "module",
     "main": "dist/index.js",
@@ -42,8 +42,8 @@
     "dependencies": {
         "@inquirer/checkbox": "5.2.1",
         "@inquirer/password": "5.1.1",
-        "@earendil-works/pi-ai": "0.79.6",
-        "@earendil-works/pi-coding-agent": "0.79.6",
+        "@earendil-works/pi-ai": "0.80.6",
+        "@earendil-works/pi-coding-agent": "0.80.6",
         "@napi-rs/keyring": "1.3.0",
         "ajv": "8.20.0",
         "chalk": "4.1.2",

package/sandbox/_node_modules/doistbot-repo-config/dist/index.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from 'doistbot-logging';
 import type { Octokit } from 'octokit';
 export declare const CONFIG_FILE_PATH = ".github/doistbot.yml";
-export declare const DEFAULT_REVIEW_MODELS: readonly ["gemini", "openai", "deepseek", "zai"];
+export declare const DEFAULT_REVIEW_MODELS: readonly ["openai", "deepseek", "zai"];
 export type DefaultReviewModel = (typeof DEFAULT_REVIEW_MODELS)[number];
 export type RepoConfig = {
     review?: {

package/sandbox/_node_modules/doistbot-repo-config/dist/index.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { load as yamlLoad } from 'js-yaml';
 export const CONFIG_FILE_PATH = '.github/doistbot.yml';
-export const DEFAULT_REVIEW_MODELS = ['gemini', 'openai', 'deepseek', 'zai'];
+export const DEFAULT_REVIEW_MODELS = ['openai', 'deepseek', 'zai'];
 function parseRepoConfigContent(content) {
     return yamlLoad(content);
 }

package/sandbox/dist/core/pi.js

@@ -13,13 +13,15 @@ export const DEFAULT_PI_MODELS = {
     deepseek: 'deepseek-v4-pro',
     gemini: 'gemini-3.1-pro-preview',
     zai: 'glm5.2',
-    openai: 'gpt-5.5',
+    openai: 'gpt-5.6-terra',
 };
 export const DEFAULT_OPENROUTER_MODELS = {
     deepseek: 'deepseek/deepseek-v4-pro',
     gemini: 'google/gemini-3.1-pro-preview',
     zai: 'z-ai/glm-5.2',
 };
+// Gemini flash fallback model.
+export const DEFAULT_GEMINI_FLASH_MODEL = 'gemini-3.5-flash';
 export const MAX_PI_THINKING_BY_PROVIDER = {
     deepseek: 'high',
     gemini: 'high',
@@ -205,6 +207,15 @@ function extractAssistantMessageResult(message) {
         ? { error: errorMessage.trim() }
         : null;
 }
+function readStopReason(message) {
+    if (!message || typeof message !== 'object') {
+        return undefined;
+    }
+    const stopReason = message.stopReason;
+    // pi's stopReason follows the PiStopReason contract; cast rather than
+    // re-validate against a runtime list that would duplicate the union.
+    return typeof stopReason === 'string' ? stopReason : undefined;
+}
 function maybeEmitProgress({ event, onProgress, lastThinkingAt, lastRespondingAt, lastToolUpdateAt, toolStartedAt, }) {
     if (!onProgress) {
         return;
@@ -352,6 +363,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                 let stderr = '';
                 let lastAssistantText = '';
                 let lastAssistantError = '';
+                let lastAssistantStopReason;
                 let sessionHeaderSeen = false;
                 const lastThinkingAt = { value: 0 };
                 const lastRespondingAt = { value: 0 };
@@ -426,6 +438,14 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                                 }
                             }
                             if (parsed.type === 'message_end') {
+                                // Read the stop reason regardless of whether the
+                                // message carried text or an error — a terminal
+                                // "length"/"error"/"aborted" ending must surface
+                                // even when there's no usable text.
+                                const stopReason = readStopReason(parsed.message);
+                                if (stopReason) {
+                                    lastAssistantStopReason = stopReason;
+                                }
                                 const result = extractAssistantMessageResult(parsed.message);
                                 if (result?.text) {
                                     lastAssistantText = result.text;
@@ -437,6 +457,10 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                             }
                             if (parsed.type === 'agent_end' && Array.isArray(parsed.messages)) {
                                 for (const message of parsed.messages) {
+                                    const stopReason = readStopReason(message);
+                                    if (stopReason) {
+                                        lastAssistantStopReason = stopReason;
+                                    }
                                     const result = extractAssistantMessageResult(message);
                                     if (result?.text) {
                                         lastAssistantText = result.text;
@@ -475,6 +499,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                             durationMs: Date.now() - startedAt,
                             timedOut,
                             toolUsage: toSortedToolUsage(toolUsageByName),
+                            stopReason: lastAssistantStopReason,
                         });
                     });
                     child.on('close', (code, signal) => {
@@ -489,6 +514,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                                 durationMs: Date.now() - startedAt,
                                 timedOut: true,
                                 toolUsage: toSortedToolUsage(toolUsageByName),
+                                stopReason: lastAssistantStopReason,
                             });
                             return;
                         }
@@ -499,6 +525,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                                 durationMs: Date.now() - startedAt,
                                 timedOut: false,
                                 toolUsage: toSortedToolUsage(toolUsageByName),
+                                stopReason: lastAssistantStopReason,
                             });
                             return;
                         }
@@ -509,6 +536,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                                 durationMs: Date.now() - startedAt,
                                 timedOut: false,
                                 toolUsage: toSortedToolUsage(toolUsageByName),
+                                stopReason: lastAssistantStopReason,
                             });
                             return;
                         }
@@ -522,6 +550,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                                 durationMs: Date.now() - startedAt,
                                 timedOut: false,
                                 toolUsage: toSortedToolUsage(toolUsageByName),
+                                stopReason: lastAssistantStopReason,
                             });
                             return;
                         }
@@ -530,6 +559,7 @@ export function createPiInvoker({ provider, apiKey, piProviderId, cwd, extraEnv,
                             output,
                             durationMs: Date.now() - startedAt,
                             toolUsage: toSortedToolUsage(toolUsageByName),
+                            stopReason: lastAssistantStopReason,
                         });
                     });
                 });

package/sandbox/dist/core/prompt-template.js

@@ -1,15 +1,57 @@
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { logger } from './logging.js';
+const promptCache = new Map();
+const resolveCache = new Map();
+/** Swap the `dist` directory nearest to the file (not just the first `/dist/` in the path) for `src`. */
+function distDirToSrcDir(dir) {
+    const distSeg = `${path.sep}dist${path.sep}`;
+    const idx = dir.lastIndexOf(distSeg);
+    if (idx === -1) {
+        return dir;
+    }
+    return `${dir.slice(0, idx)}${path.sep}src${path.sep}${dir.slice(idx + distSeg.length)}`;
+}
+/**
+ * Resolve a prompt file living in `<module>/prompts/`, relative to the calling
+ * module. At runtime the module lives under `dist/`, but the prompts are shipped
+ * under `src/`, so we map `dist`->`src`. The `dist` candidate is tried first so a
+ * future build step that copies prompts into `dist/` works without code changes.
+ */
+export function resolvePromptFile(moduleUrl, fileName) {
+    const byFileName = resolveCache.get(moduleUrl) ?? new Map();
+    resolveCache.set(moduleUrl, byFileName);
+    const cached = byFileName.get(fileName);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const dir = path.dirname(fileURLToPath(moduleUrl));
+    const candidates = [
+        path.join(dir, 'prompts', fileName),
+        path.join(distDirToSrcDir(dir), 'prompts', fileName),
+    ];
+    const resolved = candidates.find(fs.existsSync) ?? candidates[candidates.length - 1];
+    byFileName.set(fileName, resolved);
+    return resolved;
+}
 export function loadPromptTemplateFile({ fileName, promptLabel, }) {
-    const promptPath = path.resolve(fileName);
+    if (!path.isAbsolute(fileName)) {
+        throw new Error(`${promptLabel} prompt template path must be absolute (resolve it with resolvePromptFile first), got: ${fileName}`);
+    }
+    const cached = promptCache.get(fileName);
+    if (cached !== undefined) {
+        return cached;
+    }
     try {
-        return fs.readFileSync(promptPath, 'utf8');
+        const contents = fs.readFileSync(fileName, 'utf8');
+        promptCache.set(fileName, contents);
+        return contents;
     }
     catch (error) {
         logger.error(`Failed to load ${promptLabel} prompt template`, {
             error: error instanceof Error ? error.message : String(error),
-            promptPath,
+            promptPath: fileName,
         });
         throw error;
     }

package/sandbox/dist/core/repository-map.js

@@ -64,6 +64,16 @@ const TODOIST_REPOSITORIES = [
         product: 'Todoist',
         surfaces: ['android', 'ios'],
     }),
+    createRepositoryTarget({
+        repo: 'todoist-mcp',
+        product: 'Todoist',
+        surfaces: ['mcp'],
+    }),
+    createRepositoryTarget({
+        repo: 'todoist-cli',
+        product: 'Todoist',
+        surfaces: ['cli'],
+    }),
 ];
 const TWIST_REPOSITORIES = [
     createRepositoryTarget({
@@ -126,6 +136,16 @@ const TWIST_REPOSITORIES = [
         product: 'Twist',
         surfaces: ['desktop'],
     }),
+    createRepositoryTarget({
+        repo: 'twist-ai',
+        product: 'Twist',
+        surfaces: ['mcp'],
+    }),
+    createRepositoryTarget({
+        repo: 'twist-cli',
+        product: 'Twist',
+        surfaces: ['cli'],
+    }),
 ];
 function dedupeRepositories(repositories) {
     const unique = new Map();
@@ -145,8 +165,10 @@ export const APP_TO_REPO_SELECTORS = {
     all: (repositories) => dedupeRepositories(repositories),
     android: (repositories) => selectBySurface(repositories, ['android']),
     backend: (repositories) => selectBySurface(repositories, ['backend']),
+    cli: (repositories) => selectBySurface(repositories, ['cli']),
     desktop: (repositories) => selectBySurface(repositories, ['desktop']),
     ios: (repositories) => selectBySurface(repositories, ['ios']),
+    mcp: (repositories) => selectBySurface(repositories, ['mcp']),
     web: (repositories) => selectBySurface(repositories, ['web']),
 };
 export const TEAM_TO_REPO_SELECTORS = {
@@ -179,8 +201,10 @@ export const APP_LABEL_ALIASES = {
     all: 'all',
     android: 'android',
     backend: 'backend',
+    cli: 'cli',
     desktop: 'desktop',
     ios: 'ios',
+    mcp: 'mcp',
     web: 'web',
 };
 export const TEAM_LABEL_ALIASES = {

package/sandbox/dist/core/tracing.js

@@ -69,3 +69,12 @@ export function recordDecision(name, meta) {
 export function recordEvent(name, meta) {
     emitPointInTime('event', name, meta);
 }
+/**
+ * Maps a doistbot provider key to the OTel `gen_ai.provider.name` value
+ * (docs/sandbox-instrumentation.md). Only `gemini` has a standard name
+ * (`gcp.gemini`); the OpenRouter-routed keys (`zai`, `deepseek`) have none, so
+ * they pass through. Single source so every span site stays consistent.
+ */
+export function genAiProviderName(provider) {
+    return provider === 'gemini' ? 'gcp.gemini' : provider;
+}