@doist/doistbot-cli 1.0.9 → 1.0.11

package/dist/actions/auth.js

@@ -138,7 +138,7 @@ export async function runAuthSetup(dependencies = {}) {
         deps.writeLine('OpenRouter not configured. Skipping optional OpenRouter provider.');
         return;
     }
-    deps.writeLine(`Doistbot can use OpenRouter for DeepSeek, Z.ai, and other open models. Paste an OpenRouter API key, or ${formatSkipInstruction()}.`);
+    deps.writeLine(`Doistbot can use OpenRouter for DeepSeek, Grok, and other open models. Paste an OpenRouter API key, or ${formatSkipInstruction()}.`);
     const openRouterApiKey = (await deps.promptHiddenInput(API_KEY_PROMPT)).trim();
     if (!openRouterApiKey) {
         deps.writeLine();

package/dist/actions/review-usage.js

@@ -1,8 +1,8 @@
 const REVIEW_USAGE_COMMANDS = [
-    'doistbot review [--base <ref>]',
-    'doistbot review staged',
-    'db review [--base <ref>]',
-    'db review staged',
+    'doistbot review [--base <ref>] [--models <models>]',
+    'doistbot review staged [--models <models>]',
+    'db review [--base <ref>] [--models <models>]',
+    'db review staged [--models <models>]',
 ];
 const REVIEW_SETUP_COMMANDS = [
     'doistbot review',

package/dist/actions/review.js

@@ -6,6 +6,7 @@ const JSON_SCHEMA_VERSION = 1;
 const PROVIDER_DISPLAY_NAMES = {
     deepseek: 'DeepSeek',
     gemini: 'Gemini',
+    grok: 'Grok',
     zai: 'Z.ai',
     openai: 'OpenAI',
 };
@@ -198,24 +199,31 @@ function formatReviewForJson(result) {
         providerFailures: getReadableProviderFailureEntries(result.reviewResult.providerFailures),
     };
 }
-async function getReviewAuthCheck() {
-    const apiKeys = await getApiKeys();
+async function getReviewAuthCheck(models) {
+    if (models !== undefined) {
+        const configuredApiKeys = await getApiKeys(undefined, undefined, models);
+        const missingModels = models.filter((model) => configuredApiKeys[model] === undefined);
+        return {
+            apiKeys: configuredApiKeys,
+            missingModels,
+            missingProviders: missingModels.map((model) => PROVIDER_DISPLAY_NAMES[model]),
+        };
+    }
+    const configuredApiKeys = await getApiKeys();
+    const missingRequiredProviders = getMissingRequiredCliReviewAuthProviders(configuredApiKeys);
     return {
-        apiKeys,
-        missingProviders: getMissingRequiredCliReviewAuthProviders(apiKeys),
+        apiKeys: configuredApiKeys,
+        missingModels: missingRequiredProviders.includes('OpenAI') ? ['openai'] : [],
+        missingProviders: missingRequiredProviders,
     };
 }
-function getMissingAuthProviderFailures(missingProviders) {
-    const failures = [];
-    if (missingProviders.includes('OpenAI')) {
-        failures.push({
-            model: 'openai',
-            message: 'OpenAI authentication unavailable; run `doistbot auth login`',
-        });
-    }
-    return failures;
+function getMissingAuthProviderFailures(missingModels) {
+    return missingModels.map((model) => ({
+        model,
+        message: `${PROVIDER_DISPLAY_NAMES[model]} authentication unavailable; run \`doistbot auth login\``,
+    }));
 }
-function formatMissingAuthForJson({ source, missingProviders, }) {
+function formatMissingAuthForJson({ source, missingModels, }) {
     return {
         schemaVersion: JSON_SCHEMA_VERSION,
         status: 'unverified',
@@ -232,27 +240,29 @@ function formatMissingAuthForJson({ source, missingProviders, }) {
             count: 0,
             findings: [],
         },
-        providerFailures: getMissingAuthProviderFailures(missingProviders),
+        providerFailures: getMissingAuthProviderFailures(missingModels),
     };
 }
-async function runLocalReviewForCli({ source, apiKeys, onProgress, }) {
+async function runLocalReviewForCli({ source, apiKeys, models, onProgress, }) {
     const reviewModule = await loadSandboxReviewModule();
     return await reviewModule.runLocalReview({
         workspaceDir: getRepositoryRoot(),
         source,
         apiKeys,
-        ...getCliReviewRouting(apiKeys),
+        ...getCliReviewRouting(apiKeys, models),
         suppressLogs: true,
         onProgress,
     });
 }
-export async function runReview({ source, json = false } = { source: 'base' }) {
-    const authCheck = await getReviewAuthCheck();
+export async function runReview({ source, json = false, models } = {
+    source: 'base',
+}) {
+    const authCheck = await getReviewAuthCheck(models);
     if (authCheck.missingProviders.length > 0) {
         if (json) {
             writeLine(JSON.stringify(formatMissingAuthForJson({
                 source,
-                missingProviders: authCheck.missingProviders,
+                missingModels: authCheck.missingModels,
             }), null, 2));
             process.exitCode = 1;
             return;
@@ -260,7 +270,7 @@ export async function runReview({ source, json = false } = { source: 'base' }) {
         throw new Error(formatMissingRequiredCliAuthProviders(authCheck.missingProviders));
     }
     if (json) {
-        const result = await runLocalReviewForCli({ source, apiKeys: authCheck.apiKeys });
+        const result = await runLocalReviewForCli({ source, apiKeys: authCheck.apiKeys, models });
         const output = formatReviewForJson(result);
         writeLine(JSON.stringify(output, null, 2));
         if (output.status === 'unverified') {
@@ -273,6 +283,7 @@ export async function runReview({ source, json = false } = { source: 'base' }) {
         : 'Reviewing local changes...', async (status) => await runLocalReviewForCli({
         source,
         apiKeys: authCheck.apiKeys,
+        models,
         onProgress: status.enabled
             ? (event) => status.update(formatReviewProgress(event))
             : undefined,

package/dist/config.js

@@ -1,5 +1,23 @@
 import { getOpenAICodexAuthState, getStoredGeminiApiKey, getStoredOpenRouterApiKey, PI_AUTH_API_KEY, } from './auth.js';
 import { getEnvApiKeys } from './env.js';
+export const SUPPORTED_CLI_REVIEW_MODELS = [
+    'openai',
+    'deepseek',
+    'gemini',
+    'zai',
+];
+export function parseCliReviewModels(value) {
+    const models = value.split(',').map((model) => model.trim().toLowerCase());
+    if (models.some((model) => model.length === 0)) {
+        throw new Error(`--models requires a comma-separated list of: ${SUPPORTED_CLI_REVIEW_MODELS.join(', ')}`);
+    }
+    const supportedModels = new Set(SUPPORTED_CLI_REVIEW_MODELS);
+    const unsupportedModels = [...new Set(models.filter((model) => !supportedModels.has(model)))];
+    if (unsupportedModels.length > 0) {
+        throw new Error(`Unsupported review model(s): ${unsupportedModels.join(', ')}. Choose from: ${SUPPORTED_CLI_REVIEW_MODELS.join(', ')}`);
+    }
+    return [...new Set(models)];
+}
 const REQUIRED_CLI_AUTH_PROVIDERS = [{ provider: 'openai', label: 'OpenAI' }];
 const ALL_REVIEW_FOCUSES = [
     'general',
@@ -32,24 +50,36 @@ export async function getApiKeys(env = process.env, auth = {
     getStoredGeminiApiKey,
     getStoredOpenRouterApiKey,
     getOpenAICodexAuthState,
-}) {
+}, providers) {
+    const selectedProviders = providers ? new Set(providers) : undefined;
+    const needsGemini = !selectedProviders || selectedProviders.has('gemini');
+    const needsOpenRouter = !selectedProviders || selectedProviders.has('deepseek') || selectedProviders.has('zai');
+    const needsOpenAI = !selectedProviders || selectedProviders.has('openai');
     const envApiKeys = getEnvApiKeys(env);
-    const storedGeminiApiKey = envApiKeys.gemini
-        ? undefined
-        : await auth.getStoredGeminiApiKey().catch(() => undefined);
-    const storedOpenRouterApiKey = envApiKeys.openrouter
-        ? undefined
-        : await auth.getStoredOpenRouterApiKey().catch(() => undefined);
-    const openAICodexAuthState = await auth.getOpenAICodexAuthState();
+    const storedGeminiApiKey = needsGemini && !envApiKeys.gemini
+        ? await auth.getStoredGeminiApiKey().catch(() => undefined)
+        : undefined;
+    const storedOpenRouterApiKey = needsOpenRouter && !envApiKeys.openrouter
+        ? await auth.getStoredOpenRouterApiKey().catch(() => undefined)
+        : undefined;
+    // Explicit non-OpenAI runs must not refresh an unrelated OAuth session.
+    const openAICodexAuthState = needsOpenAI ? await auth.getOpenAICodexAuthState() : 'missing';
     const openRouterApiKey = envApiKeys.openrouter || storedOpenRouterApiKey;
     const apiKeys = {};
-    const geminiApiKey = envApiKeys.gemini || storedGeminiApiKey;
+    const geminiApiKey = needsGemini ? envApiKeys.gemini || storedGeminiApiKey : undefined;
     if (geminiApiKey) {
         apiKeys.gemini = createCliGeminiCredential(geminiApiKey);
     }
-    if (openRouterApiKey) {
-        apiKeys.deepseek = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
-        apiKeys.zai = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
+    if (needsOpenRouter && openRouterApiKey) {
+        if (!selectedProviders || selectedProviders.has('deepseek')) {
+            apiKeys.deepseek = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
+        }
+        if (!selectedProviders) {
+            apiKeys.grok = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
+        }
+        if (!selectedProviders || selectedProviders.has('zai')) {
+            apiKeys.zai = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
+        }
     }
     if (openAICodexAuthState === 'ready') {
         apiKeys.openai = PI_AUTH_API_KEY;
@@ -74,7 +104,23 @@ export function getMissingRequiredCliReviewAuthProviders(apiKeys) {
 export function formatMissingRequiredCliAuthProviders(missingProviders) {
     return `${missingProviders.join(' and ')} authentication unavailable (not configured, or the session could not be refreshed); run \`doistbot auth login\``;
 }
-export function getCliReviewRouting(apiKeys) {
+export function getCliReviewRouting(apiKeys, selectedModels) {
+    if (selectedModels !== undefined) {
+        if (selectedModels.length === 0) {
+            throw new Error('At least one review model must be selected.');
+        }
+        const focusModels = [...selectedModels];
+        return {
+            reviewModelsEnabled: focusModels,
+            reviewModelsByFocus: Object.fromEntries(ALL_REVIEW_FOCUSES.map((focus) => [focus, focusModels])),
+            geminiFallbackFocuses: [],
+            ...(selectedModels.includes('gemini') &&
+                !selectedModels.includes('zai') &&
+                apiKeys.gemini
+                ? { reviewSummaryModel: createCliGeminiSummaryModel(apiKeys.gemini) }
+                : {}),
+        };
+    }
     const hasGemini = Boolean(apiKeys.gemini);
     const hasOpenRouter = Boolean(apiKeys.deepseek && apiKeys.zai);
     if (hasGemini && hasOpenRouter) {

package/dist/index.js

@@ -8,6 +8,7 @@ import { runDoctor } from './actions/doctor.js';
 import { runReview } from './actions/review.js';
 import { formatReviewUsage } from './actions/review-usage.js';
 import { runSetup } from './actions/setup.js';
+import { parseCliReviewModels, SUPPORTED_CLI_REVIEW_MODELS } from './config.js';
 import { writeErrorLine } from './terminal.js';
 import { notifyAndRefreshCliUpdateCache, notifyIfCliUpdateAvailable } from './update-check.js';
 export { getSandboxRoot } from './runtime.js';
@@ -33,12 +34,16 @@ function parseReviewInput(sourceArg, options = {}) {
     if (sourceArg === LOCAL_REVIEW_SOURCE_STAGED && options.base) {
         throw new Error(formatReviewUsage());
     }
+    const reviewOptions = {
+        json: options.json === true,
+        ...(options.models !== undefined ? { models: parseCliReviewModels(options.models) } : {}),
+    };
     if (options.base !== undefined) {
-        return { source: { kind: 'base-ref', ref: options.base }, json: options.json === true };
+        return { source: { kind: 'base-ref', ref: options.base }, ...reviewOptions };
     }
     return {
         source: sourceArg === LOCAL_REVIEW_SOURCE_STAGED ? LOCAL_REVIEW_SOURCE_STAGED : 'base',
-        json: options.json === true,
+        ...reviewOptions,
     };
 }
 export function createProgram({ runAuthLogout: authLogout = runAuthLogout, runAuthSetup: authSetup = runAuthSetup, runAuthStatus: authStatus = runAuthStatus, runDoctor: doctor = runDoctor, runSetup: setup = runSetup, runReview: review = runReview, runAutomaticUpdateCheck: automaticUpdateCheck = async () => await notifyAndRefreshCliUpdateCache({
@@ -97,6 +102,7 @@ export function createProgram({ runAuthLogout: authLogout = runAuthLogout, runAu
         .command('review [source]')
         .description('Run a local self-review. Use `staged` to review only staged changes.')
         .option('--base <ref>', 'Review local changes against a specific base ref')
+        .option('--models <models>', `Use only these review models (${SUPPORTED_CLI_REVIEW_MODELS.join(', ')})`)
         .addOption(new Option('--json', 'Print machine-readable JSON instead of terminal-formatted markdown').hideHelp())
         .action(async (source, options) => await review(parseReviewInput(source, options))));
     program

package/dist/terminal.js

@@ -116,6 +116,7 @@ export async function withSpinner(message, task, terminalConfig = getDefaultTerm
 const PROVIDER_DISPLAY_NAMES = {
     deepseek: 'DeepSeek',
     gemini: 'Gemini',
+    grok: 'Grok',
     zai: 'Z.ai',
     openai: 'OpenAI',
 };
@@ -140,6 +141,10 @@ export function formatReviewProgress(event) {
             return `${PROVIDER_DISPLAY_NAMES[event.provider]} is reasoning through the changes`;
         case 'responding':
             return `${PROVIDER_DISPLAY_NAMES[event.provider]} is writing review findings`;
+        case 'limit_reached': {
+            const limit = event.level === 'soft' ? 'inspection budget' : 'inspection limit';
+            return `${PROVIDER_DISPLAY_NAMES[event.provider]} reached its ${limit} and is finalizing the review`;
+        }
         case 'tool_start':
             return event.toolName
                 ? `${PROVIDER_DISPLAY_NAMES[event.provider]} is inspecting the repo with ${event.toolName}`

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/doistbot-cli",
-    "version": "1.0.9",
+    "version": "1.0.11",
     "description": "Local self-review CLI for Doistbot",
     "type": "module",
     "main": "dist/index.js",
@@ -42,15 +42,15 @@
     "dependencies": {
         "@inquirer/checkbox": "5.2.1",
         "@inquirer/password": "5.1.1",
-        "@earendil-works/pi-ai": "0.84.2",
-        "@earendil-works/pi-coding-agent": "0.84.2",
+        "@earendil-works/pi-ai": "0.84.3",
+        "@earendil-works/pi-coding-agent": "0.84.3",
         "@napi-rs/keyring": "1.3.0",
         "ajv": "8.20.0",
         "chalk": "4.1.2",
         "commander": "14.0.3",
         "js-yaml": "4.3.1",
         "octokit": "5.0.5",
-        "undici": "8.9.0",
+        "undici": "8.10.0",
         "yocto-spinner": "1.2.0"
     },
     "devDependencies": {

package/sandbox/dist/core/datadog-metrics.js

@@ -11,6 +11,8 @@ function toTaskMetricBaseModel(model) {
         case 'gemini':
         case 'google':
             return 'google';
+        case 'grok':
+            return 'grok';
         case 'zai':
             return 'zai';
         case 'openai':
@@ -29,13 +31,16 @@ function normalizeMetricRepository(repository) {
     const normalized = repository.trim().toLowerCase();
     return normalized || 'unknown';
 }
-function buildTaskMetricTags({ type, repository, model, outcome, reason, }) {
+function buildTaskMetricTags({ type, repository, model, outcome, reason, sandboxVariant, }) {
     const tags = [
         `type:${type}`,
         `repo:${normalizeMetricRepository(repository)}`,
         `model:${model}`,
         `status:${outcome}`,
     ];
+    if (sandboxVariant) {
+        tags.push(`sandbox_variant:${sandboxVariant}`);
+    }
     if (reason) {
         tags.push(`reason:${reason}`);
     }
@@ -44,7 +49,7 @@ function buildTaskMetricTags({ type, repository, model, outcome, reason, }) {
     }
     return tags;
 }
-export async function recordTaskMetrics({ type, repository, model, outcome, durationMs, reason, }) {
+export async function recordTaskMetrics({ type, repository, model, outcome, durationMs, reason, sandboxVariant, }) {
     const apiKey = resolveDatadogApiKey();
     if (!apiKey) {
         if (!hasWarnedAboutMissingDatadogApiKey) {
@@ -54,6 +59,7 @@ export async function recordTaskMetrics({ type, repository, model, outcome, dura
                 repository: normalizeMetricRepository(repository),
                 model: toTaskMetricModel(model),
                 outcome,
+                ...(sandboxVariant ? { sandboxVariant } : {}),
                 ...(reason ? { reason } : {}),
             });
         }
@@ -68,6 +74,7 @@ export async function recordTaskMetrics({ type, repository, model, outcome, dura
         model: metricModel,
         outcome,
         reason,
+        sandboxVariant,
     });
     await Promise.allSettled([
         postDatadogMetric({

package/sandbox/dist/core/label-parsing.js

@@ -1,22 +1 @@
-export function normalizeScopedLabelValue(value) {
-    return value.trim().toLowerCase().replace(/\s+/g, '-');
-}
-export function scopedLabelValue(label, scope) {
-    const prefix = `${scope.toLowerCase()}:`;
-    const trimmed = label.trim();
-    if (!trimmed.toLowerCase().startsWith(prefix)) {
-        return null;
-    }
-    const value = trimmed.slice(scope.length + 1).trim();
-    return value ? value : null;
-}
-export function extractScopedLabelValues(labels, scope) {
-    const values = [];
-    for (const label of labels) {
-        const value = scopedLabelValue(label, scope);
-        if (value) {
-            values.push(value);
-        }
-    }
-    return values;
-}
+export { extractScopedLabelValues, normalizeScopedLabelValue, scopedLabelValue, } from 'doistbot-issue-routing';

package/sandbox/dist/core/pi-execution-limits-extension.js

@@ -0,0 +1,79 @@
+export const PI_EXECUTION_LIMIT_ENV = {
+    startedAtMs: 'DOISTBOT_PI_LIMIT_STARTED_AT_MS',
+    softTimeMs: 'DOISTBOT_PI_SOFT_TIME_LIMIT_MS',
+    softToolCalls: 'DOISTBOT_PI_SOFT_TOOL_LIMIT',
+    hardTimeMs: 'DOISTBOT_PI_HARD_TIME_LIMIT_MS',
+    hardToolCalls: 'DOISTBOT_PI_HARD_TOOL_LIMIT',
+};
+const SOFT_LIMIT_MESSAGE = 'The inspection budget is nearly complete. Stop gathering new context and return the requested final result now using the evidence you already have.';
+const HARD_LIMIT_MESSAGE = 'The inspection budget is complete. Do not request more tools. Return the requested final result immediately using the evidence you already have.';
+const HARD_TOOL_BLOCK_REASON = 'The inspection budget is complete. No more tool calls are available. Return the final result now.';
+function readPositiveInteger(name) {
+    // Keep this parser local. Pi loads this file as a standalone extension, so
+    // importing shared application helpers would also load their dependencies.
+    const parsed = Number(process.env[name]);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+// Pi's extension loader requires a default export.
+// eslint-disable-next-line import/no-default-export
+export default function executionLimitsExtension(pi) {
+    const startedAtMs = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.startedAtMs) ?? Date.now();
+    const softTimeMs = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.softTimeMs);
+    const softToolCalls = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.softToolCalls);
+    const hardTimeMs = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.hardTimeMs);
+    const hardToolCalls = readPositiveInteger(PI_EXECUTION_LIMIT_ENV.hardToolCalls);
+    let timersStarted = false;
+    let softLimitReached = false;
+    let hardLimitReached = false;
+    let toolCallCount = 0;
+    const timers = [];
+    function steer(message) {
+        pi.sendUserMessage(message, { deliverAs: 'steer' });
+    }
+    function reachSoftLimit() {
+        if (softLimitReached)
+            return;
+        softLimitReached = true;
+        steer(SOFT_LIMIT_MESSAGE);
+    }
+    function reachHardLimit() {
+        if (hardLimitReached)
+            return;
+        hardLimitReached = true;
+        softLimitReached = true;
+        steer(HARD_LIMIT_MESSAGE);
+    }
+    function scheduleAtElapsed(elapsedMs, callback) {
+        const remainingMs = Math.max(0, elapsedMs - (Date.now() - startedAtMs));
+        timers.push(setTimeout(callback, remainingMs));
+    }
+    pi.on('agent_start', () => {
+        if (timersStarted)
+            return;
+        timersStarted = true;
+        if (softTimeMs)
+            scheduleAtElapsed(softTimeMs, reachSoftLimit);
+        if (hardTimeMs)
+            scheduleAtElapsed(hardTimeMs, reachHardLimit);
+    });
+    pi.on('tool_call', () => {
+        if (hardLimitReached) {
+            return { block: true, reason: HARD_TOOL_BLOCK_REASON };
+        }
+        toolCallCount += 1;
+        if (softToolCalls && toolCallCount >= softToolCalls) {
+            reachSoftLimit();
+        }
+        if (hardToolCalls && toolCallCount >= hardToolCalls) {
+            // The call that reaches the hard limit is allowed to finish. All
+            // later calls are blocked so the model can submit its current work.
+            reachHardLimit();
+        }
+        return undefined;
+    });
+    pi.on('agent_settled', () => {
+        for (const timer of timers)
+            clearTimeout(timer);
+        timers.length = 0;
+    });
+}

package/sandbox/dist/core/pi-progress-logging.js

@@ -15,6 +15,10 @@ export function logPiProgressEvent({ event, messages, meta, logResponding = fals
                 logger.info(messages.responding, meta);
             }
             return;
+        // Callers that opt into execution limits handle this event with
+        // task-specific messages, severity, and metadata.
+        case 'limit_reached':
+            return;
         case 'tool_start':
             if (logTools) {
                 const log = toolLogLevel === 'warn' ? logger.warn : logger.info;