create-quiver 0.14.1 → 0.15.1

package/src/create-quiver/commands/ai.js

@@ -13,10 +13,17 @@ const {
 const { buildContextPackMetadata, normalizeRole } = require('../lib/ai/context-packs');
 const { parseContextProposalOutput } = require('../lib/ai/context-proposal');
 const { openEditor } = require('../lib/cli/editor');
+const { selectOption, promptText } = require('../lib/cli/selectors');
 const { createUx } = require('../lib/cli/ux');
 const { runExecuteSlice, runPromptSlice } = require('../lib/ai/executor');
 const { runExecutePlan } = require('../lib/ai/execution-plan');
 const { buildPrCreatePlan, formatPreflightReport, formatPrCreateReport, preflightGitHubPr, runGhPrCreate } = require('../lib/ai/github');
+const {
+  MODEL_CATALOG_LAST_UPDATED,
+  MODEL_CATALOG_VERSION,
+  getKnownModelsForProvider,
+  listCatalogProviders,
+} = require('../lib/ai/model-catalog');
 const { buildContextPreparationDrafts, buildPlannerOnboardingPrompt } = require('../lib/ai/onboarding-template');
 const {
   collectLifecycleExport,
@@ -43,6 +50,7 @@ const {
   validateTechnicalPlanSpecContract,
 } = require('../lib/ai/spec-generator');
 const { buildProviderInvocation, runProvider } = require('../lib/ai/providers');
+const { preflightProvider } = require('../lib/ai/preflight');
 const {
   createAiRun,
   ensureAiRun,
@@ -55,9 +63,15 @@ const {
 } = require('../lib/ai/run-state');
 const {
   agentProfilesPath,
+  buildAgentProfileDoctorReport,
+  buildAgentProfileRepairPlan,
   buildAgentProfileState,
   getAgentProfile,
+  getAgentProfileById,
+  getAgentProfilesForRole,
   listAgentProfiles,
+  normalizeAgentProfileRole,
+  resolveAgentProfileDisplayName,
   resolveProfileProvider,
   setAgentProfile,
 } = require('../lib/agent-profiles');
@@ -122,11 +136,126 @@ function normalizeTimeout(timeoutMs) {
   return parsed;
 }
 
-function resolveProviderForProfile(repoRoot, role, provider, providerExplicit, fallbackProvider) {
-  if (providerExplicit === true || (provider && providerExplicit !== false)) {
-    return String(provider || fallbackProvider).trim().toLowerCase();
+function profileOptionForRole(options, role) {
+  const normalized = normalizeAgentProfileRole(role);
+  if (normalized === 'planner') {
+    return options.plannerProfile || options.profileId || '';
+  }
+  if (normalized === 'executor') {
+    return options.executorProfile || options.profileId || '';
+  }
+  if (normalized === 'reviewer') {
+    return options.reviewerProfile || options.profileId || '';
+  }
+  if (normalized === 'doctor') {
+    return options.doctorProfile || options.profileId || '';
+  }
+  return options.profileId || '';
+}
+
+function resolveRuntimeAgentProfile(repoRoot, role, options = {}, fallbackProvider = DEFAULT_PLAN_PROVIDER) {
+  const normalizedRole = normalizeAgentProfileRole(role);
+  const explicitProvider = options.providerExplicit === true || (options.provider && options.providerExplicit !== false);
+  const explicitModel = String(options.model || '').trim();
+
+  if (explicitProvider) {
+    const provider = String(options.provider || fallbackProvider).trim().toLowerCase();
+    return {
+      role: normalizedRole,
+      profile: null,
+      profileId: '',
+      displayName: provider,
+      provider,
+      model: explicitModel,
+    };
+  }
+
+  const profileId = profileOptionForRole(options, normalizedRole);
+  const profile = profileId
+    ? getAgentProfileById(repoRoot, normalizedRole, profileId)
+    : getAgentProfile(repoRoot, normalizedRole);
+  const provider = profile?.provider || resolveProfileProvider(repoRoot, normalizedRole, fallbackProvider);
+
+  return {
+    role: normalizedRole,
+    profile,
+    profileId: profile?.id || profileId || '',
+    displayName: profile ? resolveAgentProfileDisplayName(profile) : provider,
+    provider,
+    model: explicitModel || profile?.model || '',
+  };
+}
+
+function runtimeModelExecutionOptions(runtimeProfile, options = {}) {
+  return {
+    model: runtimeProfile.model,
+    blockModelAlias: Boolean(runtimeProfile.profile && !String(options.model || '').trim()),
+  };
+}
+
+function createCommandUx(options = {}) {
+  if (options.ux) {
+    return options.ux;
+  }
+
+  return createUx({
+    env: options.env || process.env,
+    input: options.inputStream,
+    output: options.outputStream,
+    error: options.errorStream,
+    interactive: options.interactive,
+    json: options.json,
+    noColor: options.noColor,
+    prompts: options.prompts,
+    spinner: options.spinner,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    stderrIsTTY: options.stderrIsTTY,
+    write: options.write,
+  });
+}
+
+function shouldShowHumanProgress(ux, options = {}) {
+  return options.progress !== false
+    && options.dryRun !== true
+    && options.printPrompt !== true
+    && ux?.mode?.decoration === true;
+}
+
+function plannerProgressTitle(action, runtimeProfile) {
+  return `${action} con ${runtimeProfile.displayName || runtimeProfile.model || runtimeProfile.provider}`;
+}
+
+function writeProgressChecks(ux, enabled, title, checks = []) {
+  if (!enabled) {
+    return;
+  }
+  ux.heading(title);
+  for (const check of checks) {
+    ux.check(check);
+  }
+}
+
+async function runProviderWithProgress({ ux, enabled, message = 'Ejecutando agente...', successMessage = 'Agente finalizado', failureMessage = 'Fallo ejecutando agente', run }) {
+  async function runAndFailOnProviderResult() {
+    const result = await run();
+    if (result && result.ok === false) {
+      const error = new Error(result.error?.message || 'provider run failed');
+      error.code = result.error?.code || 'AI_PROVIDER_RUN_FAILED';
+      error.providerResult = result;
+      throw error;
+    }
+    return result;
+  }
+
+  if (!enabled) {
+    return run();
   }
-  return resolveProfileProvider(repoRoot, role, fallbackProvider);
+
+  return ux.withSpinner(message, runAndFailOnProviderResult, {
+    successMessage,
+    failureMessage,
+  });
 }
 
 function buildPlanContext({ role, context, phase, inputText, inputPath, repoRoot, revise = false }) {
@@ -210,6 +339,10 @@ function formatDryRunReport({ task, provider, role, contextPack, phase, invocati
   lines.push(`Timeout: ${invocation.timeoutMs}ms`);
   lines.push(`Prompt transport: ${invocation.promptTransport.mode}`);
   lines.push(`Prompt length: ${invocation.promptLength} bytes`);
+  if (invocation.modelSelection && invocation.modelSelection.model) {
+    lines.push(`Model: ${invocation.modelSelection.model}`);
+    lines.push(`Model support: ${invocation.modelSelection.supported ? 'supported' : 'unsupported'} (${invocation.modelSelection.reason})`);
+  }
 
   if (onboardingPlan) {
     lines.push(`Prompt source: ${onboardingPlan.promptSource}`);
@@ -236,6 +369,10 @@ function formatPromptOnlyReport({ task, provider, role, contextPack, phase, invo
   lines.push(`Timeout: ${invocation.timeoutMs}ms`);
   lines.push(`Prompt transport: ${invocation.promptTransport.mode}`);
   lines.push(`Prompt length: ${invocation.promptLength} bytes`);
+  if (invocation.modelSelection && invocation.modelSelection.model) {
+    lines.push(`Model: ${invocation.modelSelection.model}`);
+    lines.push(`Model support: ${invocation.modelSelection.supported ? 'supported' : 'unsupported'} (${invocation.modelSelection.reason})`);
+  }
 
   if (onboardingPlan) {
     lines.push(`Prompt source: ${onboardingPlan.promptSource}`);
@@ -407,6 +544,12 @@ function formatPrepareContextPlannerDryRunReport({ provider, role, context, invo
     `Context pack: ${context}`,
     `Command: ${invocation.command} ${invocation.args.join(' ')}`.trim(),
     `Prompt bytes: ${invocation.promptLength}`,
+    invocation.modelSelection && invocation.modelSelection.model
+      ? `Model: ${invocation.modelSelection.model}`
+      : '',
+    invocation.modelSelection && invocation.modelSelection.model
+      ? `Model support: ${invocation.modelSelection.supported ? 'supported' : 'unsupported'} (${invocation.modelSelection.reason})`
+      : '',
     `Prompt source: ${promptInfo.promptSource}`,
     `Review requested: ${review ? 'yes' : 'no'}`,
     `Interactive requested: ${interactive ? 'yes' : 'no'}`,
@@ -424,7 +567,7 @@ function formatPrepareContextPlannerDryRunReport({ provider, role, context, invo
     '- npx create-quiver ai prepare-context --with-planner',
   ];
 
-  return `${lines.join('\n')}\n`;
+  return `${lines.filter(Boolean).join('\n')}\n`;
 }
 
 function serializeProposalForReview(proposal) {
@@ -1108,7 +1251,8 @@ function annotateGitHubError(error, scope) {
 
 async function runOnboard(repoRoot, options = {}) {
   const role = normalizeRole(options.role || DEFAULT_ONBOARD_ROLE);
-  const provider = resolveProviderForProfile(repoRoot, role, options.provider, options.providerExplicit, DEFAULT_ONBOARD_PROVIDER);
+  const runtimeProfile = resolveRuntimeAgentProfile(repoRoot, role, options, DEFAULT_ONBOARD_PROVIDER);
+  const provider = runtimeProfile.provider;
   const context = options.context || DEFAULT_ONBOARD_CONTEXT;
   const timeoutMs = normalizeTimeout(options.timeout);
   const inputText = readTextFile(options.input, repoRoot);
@@ -1121,9 +1265,15 @@ async function runOnboard(repoRoot, options = {}) {
       prompt,
       cwd: repoRoot,
       timeoutMs,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+      enforceModelSelection: false,
     });
   } catch (error) {
-    throw annotateProviderError(error, 'onboard');
+    if (error.providerResult) {
+      result = error.providerResult;
+    } else {
+      throw annotateProviderError(error, 'onboard');
+    }
   }
 
   if (options.dryRun) {
@@ -1134,6 +1284,7 @@ async function runOnboard(repoRoot, options = {}) {
       contextPack: context,
       invocation,
       onboardingPlan: contextInfo.plan,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatDryRunReport(report));
     return report;
@@ -1148,23 +1299,39 @@ async function runOnboard(repoRoot, options = {}) {
       invocation,
       onboardingPlan: contextInfo.plan,
       prompt,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatPromptOnlyReport(report));
     return report;
   }
 
+  const ux = createCommandUx(options);
+  const showProgress = shouldShowHumanProgress(ux, options);
+  writeProgressChecks(
+    ux,
+    showProgress,
+    plannerProgressTitle('Ejecutando onboarding', runtimeProfile),
+    ['Leyendo docs base', 'Detectando estructura', 'Preparando prompt'],
+  );
+
   let result;
   try {
-    result = await (options.runProviderFn || runProvider)(provider, {
-      prompt,
-      cwd: repoRoot,
-      timeoutMs,
-      dryRun: false,
-      probe: options.probe,
-      spawn: options.spawn,
-      tempRoot: options.tempRoot,
-      tempFileName: options.tempFileName,
-      tempFilePrefix: options.tempFilePrefix,
+    result = await runProviderWithProgress({
+      ux,
+      enabled: showProgress,
+      run: () => (options.runProviderFn || runProvider)(provider, {
+        prompt,
+        cwd: repoRoot,
+        timeoutMs,
+        dryRun: false,
+        probe: options.probe,
+        spawn: options.spawn,
+        tempRoot: options.tempRoot,
+        tempFileName: options.tempFileName,
+        tempFilePrefix: options.tempFilePrefix,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+        enforceModelSelection: Boolean(runtimeProfile.model),
+      }),
     });
   } catch (error) {
     throw annotateProviderError(error, 'onboard');
@@ -1185,6 +1352,7 @@ async function runOnboard(repoRoot, options = {}) {
     contextPack: context,
     invocation,
     onboardingPlan: contextInfo.plan,
+    profile: runtimeProfile,
     result,
   };
 }
@@ -1257,7 +1425,8 @@ async function runPrepareContext(repoRoot, options = {}) {
 
 async function runPrepareContextWithPlanner(repoRoot, options = {}) {
   const role = normalizeRole(options.role || DEFAULT_PLAN_ROLE);
-  const provider = resolveProviderForProfile(repoRoot, role, options.provider, options.providerExplicit, DEFAULT_PLAN_PROVIDER);
+  const runtimeProfile = resolveRuntimeAgentProfile(repoRoot, role, options, DEFAULT_PLAN_PROVIDER);
+  const provider = runtimeProfile.provider;
   const context = options.context || DEFAULT_PLAN_CONTEXT;
   const timeoutMs = normalizeTimeout(options.timeout);
   const draftPack = buildContextPreparationDrafts(repoRoot);
@@ -1276,9 +1445,15 @@ async function runPrepareContextWithPlanner(repoRoot, options = {}) {
       prompt,
       cwd: repoRoot,
       timeoutMs,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+      enforceModelSelection: false,
     });
   } catch (error) {
-    throw annotateProviderError(error, 'prepare-context');
+    if (error.providerResult) {
+      result = error.providerResult;
+    } else {
+      throw annotateProviderError(error, 'prepare-context');
+    }
   }
 
   if (options.dryRun) {
@@ -1292,6 +1467,7 @@ async function runPrepareContextWithPlanner(repoRoot, options = {}) {
       invocation,
       candidateDocs: promptInfo.allowedPaths,
       plan: draftPack.plan,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatPrepareContextPlannerDryRunReport({
       provider,
@@ -1314,23 +1490,39 @@ async function runPrepareContextWithPlanner(repoRoot, options = {}) {
       invocation,
       prompt,
       promptSource: promptInfo.promptSource,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatPromptOnlyReport(report));
     return report;
   }
 
+  const ux = createCommandUx(options);
+  const showProgress = shouldShowHumanProgress(ux, options);
+  writeProgressChecks(
+    ux,
+    showProgress,
+    plannerProgressTitle('Ejecutando onboarding', runtimeProfile),
+    ['Leyendo docs base', 'Detectando estructura', 'Preparando prompt'],
+  );
+
   let result;
   try {
-    result = await (options.runProviderFn || runProvider)(provider, {
-      prompt,
-      cwd: repoRoot,
-      timeoutMs,
-      dryRun: false,
-      probe: options.probe,
-      spawn: options.spawn,
-      tempRoot: options.tempRoot,
-      tempFileName: options.tempFileName,
-      tempFilePrefix: options.tempFilePrefix,
+    result = await runProviderWithProgress({
+      ux,
+      enabled: showProgress,
+      run: () => (options.runProviderFn || runProvider)(provider, {
+        prompt,
+        cwd: repoRoot,
+        timeoutMs,
+        dryRun: false,
+        probe: options.probe,
+        spawn: options.spawn,
+        tempRoot: options.tempRoot,
+        tempFileName: options.tempFileName,
+        tempFilePrefix: options.tempFilePrefix,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+        enforceModelSelection: Boolean(runtimeProfile.model),
+      }),
     });
   } catch (error) {
     throw annotateProviderError(error, 'prepare-context');
@@ -1404,7 +1596,8 @@ async function runPrepareContextWithPlanner(repoRoot, options = {}) {
 async function runPlan(repoRoot, options = {}) {
   const phase = normalizePlannerPhase(options.phase || DEFAULT_PLAN_PHASE);
   const role = normalizeRole(options.role || DEFAULT_PLAN_ROLE);
-  const provider = resolveProviderForProfile(repoRoot, role, options.provider, options.providerExplicit, DEFAULT_PLAN_PROVIDER);
+  const runtimeProfile = resolveRuntimeAgentProfile(repoRoot, role, options, DEFAULT_PLAN_PROVIDER);
+  const provider = runtimeProfile.provider;
   const context = options.context || DEFAULT_PLAN_CONTEXT;
   const timeoutMs = normalizeTimeout(options.timeout);
   let inputPath = options.input || '';
@@ -1506,9 +1699,15 @@ async function runPlan(repoRoot, options = {}) {
       prompt,
       cwd: repoRoot,
       timeoutMs,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+      enforceModelSelection: false,
     });
   } catch (error) {
-    throw annotateProviderError(error, 'plan', phase);
+    if (error.providerResult) {
+      result = error.providerResult;
+    } else {
+      throw annotateProviderError(error, 'plan', phase);
+    }
   }
 
   if (options.dryRun) {
@@ -1519,6 +1718,7 @@ async function runPlan(repoRoot, options = {}) {
       contextPack: contextInfo.pack.packName,
       phase,
       invocation,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatDryRunReport(report));
     if (options.withPlanner === true) {
@@ -1542,23 +1742,39 @@ async function runPlan(repoRoot, options = {}) {
       phase,
       invocation,
       prompt,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatPromptOnlyReport(report));
     return report;
   }
 
+  const ux = createCommandUx(options);
+  const showProgress = shouldShowHumanProgress(ux, options);
+  writeProgressChecks(
+    ux,
+    showProgress,
+    plannerProgressTitle(`Ejecutando plan ${phase}`, runtimeProfile),
+    ['Leyendo entrada', 'Preparando contexto', 'Preparando prompt'],
+  );
+
   let result;
   try {
-    result = await (options.runProviderFn || runProvider)(provider, {
-      prompt,
-      cwd: repoRoot,
-      timeoutMs,
-      dryRun: false,
-      probe: options.probe,
-      spawn: options.spawn,
-      tempRoot: options.tempRoot,
-      tempFileName: options.tempFileName,
-      tempFilePrefix: options.tempFilePrefix,
+    result = await runProviderWithProgress({
+      ux,
+      enabled: showProgress,
+      run: () => (options.runProviderFn || runProvider)(provider, {
+        prompt,
+        cwd: repoRoot,
+        timeoutMs,
+        dryRun: false,
+        probe: options.probe,
+        spawn: options.spawn,
+        tempRoot: options.tempRoot,
+        tempFileName: options.tempFileName,
+        tempFilePrefix: options.tempFilePrefix,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+        enforceModelSelection: Boolean(runtimeProfile.model),
+      }),
     });
   } catch (error) {
     throw annotateProviderError(error, 'plan', phase);
@@ -1625,7 +1841,8 @@ async function runPlan(repoRoot, options = {}) {
 
 async function runReviewPlan(repoRoot, options = {}) {
   const role = 'planner';
-  const provider = resolveProviderForProfile(repoRoot, 'reviewer', options.provider, options.providerExplicit, DEFAULT_PLAN_PROVIDER);
+  const runtimeProfile = resolveRuntimeAgentProfile(repoRoot, 'reviewer', options, DEFAULT_PLAN_PROVIDER);
+  const provider = runtimeProfile.provider;
   const context = options.context || DEFAULT_PLAN_CONTEXT;
   const timeoutMs = normalizeTimeout(options.timeout);
   const resolved = resolveTechnicalPlanReviewInput(repoRoot, options.input || undefined);
@@ -1649,9 +1866,15 @@ async function runReviewPlan(repoRoot, options = {}) {
       prompt: built.prompt,
       cwd: repoRoot,
       timeoutMs,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+      enforceModelSelection: false,
     });
   } catch (error) {
-    throw annotateProviderError(error, 'review-plan');
+    if (error.providerResult) {
+      result = error.providerResult;
+    } else {
+      throw annotateProviderError(error, 'review-plan');
+    }
   }
 
   if (options.dryRun) {
@@ -1665,6 +1888,7 @@ async function runReviewPlan(repoRoot, options = {}) {
       inputPath,
       inputKind: resolved.kind,
       inputVersion: resolved.version,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatDryRunReport({
       task: 'review-plan',
@@ -1696,23 +1920,39 @@ async function runReviewPlan(repoRoot, options = {}) {
       inputPath,
       inputKind: resolved.kind,
       inputVersion: resolved.version,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatPromptOnlyReport(report));
     return report;
   }
 
+  const ux = createCommandUx(options);
+  const showProgress = shouldShowHumanProgress(ux, options);
+  writeProgressChecks(
+    ux,
+    showProgress,
+    plannerProgressTitle('Ejecutando revisión del plan', runtimeProfile),
+    ['Leyendo plan técnico', 'Preparando contexto', 'Preparando prompt'],
+  );
+
   let result;
   try {
-    result = await (options.runProviderFn || runProvider)(provider, {
-      prompt: built.prompt,
-      cwd: repoRoot,
-      timeoutMs,
-      dryRun: false,
-      probe: options.probe,
-      spawn: options.spawn,
-      tempRoot: options.tempRoot,
-      tempFileName: options.tempFileName,
-      tempFilePrefix: options.tempFilePrefix,
+    result = await runProviderWithProgress({
+      ux,
+      enabled: showProgress,
+      run: () => (options.runProviderFn || runProvider)(provider, {
+        prompt: built.prompt,
+        cwd: repoRoot,
+        timeoutMs,
+        dryRun: false,
+        probe: options.probe,
+        spawn: options.spawn,
+        tempRoot: options.tempRoot,
+        tempFileName: options.tempFileName,
+        tempFilePrefix: options.tempFilePrefix,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+        enforceModelSelection: Boolean(runtimeProfile.model),
+      }),
     });
   } catch (error) {
     throw annotateProviderError(error, 'review-plan');
@@ -1770,7 +2010,8 @@ async function runReviewPlan(repoRoot, options = {}) {
 
 async function runRepairPlan(repoRoot, options = {}) {
   const role = normalizeRole(options.role || DEFAULT_PLAN_ROLE);
-  const provider = resolveProviderForProfile(repoRoot, role, options.provider, options.providerExplicit, DEFAULT_PLAN_PROVIDER);
+  const runtimeProfile = resolveRuntimeAgentProfile(repoRoot, role, options, DEFAULT_PLAN_PROVIDER);
+  const provider = runtimeProfile.provider;
   const context = options.context || DEFAULT_PLAN_CONTEXT;
   const timeoutMs = normalizeTimeout(options.timeout);
   const source = resolveApprovedTechnicalPlanForRepair(repoRoot, options.input || '');
@@ -1790,9 +2031,15 @@ async function runRepairPlan(repoRoot, options = {}) {
       prompt: built.prompt,
       cwd: repoRoot,
       timeoutMs,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+      enforceModelSelection: false,
     });
   } catch (error) {
-    throw annotateProviderError(error, 'repair-plan');
+    if (error.providerResult) {
+      providerResult = error.providerResult;
+    } else {
+      throw annotateProviderError(error, 'repair-plan');
+    }
   }
 
   if (options.dryRun) {
@@ -1803,6 +2050,7 @@ async function runRepairPlan(repoRoot, options = {}) {
       contextPack: built.pack.packName,
       phase: 'technical-plan',
       invocation,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatDryRunReport(report));
     process.stdout.write(`Source approved artifact: ${source.path}\n`);
@@ -1822,23 +2070,39 @@ async function runRepairPlan(repoRoot, options = {}) {
       inputPath: source.path,
       inputKind: 'approved',
       inputVersion: source.approval.meta?.approved?.version || null,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatPromptOnlyReport(report));
     return report;
   }
 
+  const ux = createCommandUx(options);
+  const showProgress = shouldShowHumanProgress(ux, options);
+  writeProgressChecks(
+    ux,
+    showProgress,
+    plannerProgressTitle('Ejecutando reparación del plan', runtimeProfile),
+    ['Leyendo plan aprobado', 'Preparando contexto', 'Preparando prompt'],
+  );
+
   let providerResult;
   try {
-    providerResult = await (options.runProviderFn || runProvider)(provider, {
-      prompt: built.prompt,
-      cwd: repoRoot,
-      timeoutMs,
-      dryRun: false,
-      probe: options.probe,
-      spawn: options.spawn,
-      tempRoot: options.tempRoot,
-      tempFileName: options.tempFileName,
-      tempFilePrefix: options.tempFilePrefix,
+    providerResult = await runProviderWithProgress({
+      ux,
+      enabled: showProgress,
+      run: () => (options.runProviderFn || runProvider)(provider, {
+        prompt: built.prompt,
+        cwd: repoRoot,
+        timeoutMs,
+        dryRun: false,
+        probe: options.probe,
+        spawn: options.spawn,
+        tempRoot: options.tempRoot,
+        tempFileName: options.tempFileName,
+        tempFilePrefix: options.tempFilePrefix,
+        ...runtimeModelExecutionOptions(runtimeProfile, options),
+        enforceModelSelection: Boolean(runtimeProfile.model),
+      }),
     });
   } catch (error) {
     throw annotateProviderError(error, 'repair-plan');
@@ -2172,12 +2436,221 @@ function runLifecycleRun(repoRoot, options = {}) {
   };
 }
 
+function isInteractiveAgentPromptAvailable(options = {}) {
+  const stdinIsTTY = options.stdinIsTTY ?? Boolean((options.input || process.stdin).isTTY);
+  const stdoutIsTTY = options.stdoutIsTTY ?? Boolean((options.output || process.stdout).isTTY);
+  const ci = String((options.env || process.env).CI || '').trim().toLowerCase();
+  return stdinIsTTY && stdoutIsTTY && ci !== '1' && ci !== 'true';
+}
+
+function providerInstallHint(repoRoot, providerId, options = {}) {
+  const probe = options.preflightProvider || preflightProvider;
+  try {
+    probe(providerId, {
+      cwd: repoRoot,
+      probe: options.providerProbe,
+      probeArgs: options.providerProbeArgs,
+    });
+    return 'installed';
+  } catch (error) {
+    if (error && error.code === 'MISSING_PROVIDER_CLI') {
+      return 'not installed';
+    }
+    return 'not verified';
+  }
+}
+
+function buildAgentProviderChoices(repoRoot, options = {}) {
+  return listCatalogProviders().map((provider) => {
+    const status = providerInstallHint(repoRoot, provider.id, options);
+    return {
+      label: provider.displayName,
+      value: provider.id,
+      hint: `${provider.modelCount} models, ${status}`,
+      raw: {
+        ...provider,
+        installStatus: status,
+      },
+    };
+  });
+}
+
+function buildAgentModelChoices(provider, role) {
+  return getKnownModelsForProvider(provider, { role }).map((model) => {
+    const recommended = model.recommendedFor.includes(role) ? 'recommended' : 'available';
+    const tier = [model.costTier, model.qualityTier, model.stability].filter(Boolean).join('/');
+    return {
+      label: model.displayName,
+      value: model.id,
+      hint: [recommended, tier].filter(Boolean).join(', '),
+      default: model.recommendedFor.includes(role),
+      raw: model,
+    };
+  });
+}
+
+async function resolveInteractiveAgentSetOptions(repoRoot, options = {}) {
+  const role = normalizeAgentProfileRole(options.role);
+  const hasProvider = Boolean(String(options.provider || '').trim());
+  const hasModel = Boolean(String(options.model || '').trim());
+  if (hasProvider && hasModel) {
+    return {
+      ...options,
+      role,
+    };
+  }
+
+  const canPrompt = isInteractiveAgentPromptAvailable(options);
+  const shouldPrompt = options.interactive === true || canPrompt;
+  if (!shouldPrompt || !canPrompt) {
+    throw new Error(formatActionableError({
+      failure: `ai agent set ${role} requires --provider and --model when prompts are not available.`,
+      impact: 'Quiver cannot safely guess the provider or technical model id for an agent profile.',
+      fix: 'Pass both flags explicitly, or rerun from an interactive terminal with --interactive.',
+      nextCommand: `npx create-quiver ai agent set ${role} --provider codex --model gpt-5.5`,
+    }));
+  }
+
+  const promptOptions = {
+    env: options.env,
+    error: options.error,
+    input: options.input,
+    interactive: true,
+    noColor: options.noColor,
+    output: options.output,
+    prompts: options.prompts,
+    promptSelect: options.promptSelect,
+    promptText: options.promptText,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    stderrIsTTY: options.stderrIsTTY,
+    write: options.write,
+  };
+
+  const existingProfiles = getAgentProfilesForRole(repoRoot, role);
+  let next = { ...options, role };
+  if (existingProfiles.length > 0 && !options.id && !options.defaultProfile) {
+    const ux = createCommandUx(promptOptions);
+    ux.summary(existingProfiles.map((profile) => ({
+      label: profile.id,
+      value: `${profile.provider} ${profile.model || '(no model)'}${profile.default ? ' default' : ''}`,
+    })), {
+      title: `Existing ${role} profiles`,
+    });
+
+    const action = await selectOption(`Ya existe al menos un perfil ${role}. ¿Qué querés hacer?`, [
+      { label: 'Actualizar perfil actual', value: 'update-current', hint: 'Reutiliza el perfil default', default: true },
+      { label: 'Crear perfil nuevo', value: 'create-new', hint: 'Permite guardar otro modelo o provider' },
+      { label: 'Cambiar default', value: 'change-default', hint: 'Marca un perfil existente como default' },
+      { label: 'Cancelar', value: 'cancel', hint: 'No escribe archivos' },
+    ], {
+      ...promptOptions,
+      name: 'agent profile action',
+      flag: '--id',
+    });
+
+    if (action.value === 'cancel') {
+      throw new Error(formatError('ai agent set canceled. No files were written.'));
+    }
+
+    if (action.value === 'change-default') {
+      const profile = await selectOption(`Elegí el perfil ${role} default`, existingProfiles.map((item) => ({
+        label: resolveAgentProfileDisplayName(item),
+        value: item.id,
+        hint: `${item.provider} ${item.model || '(no model)'}`,
+        default: item.default === true,
+        raw: item,
+      })), {
+        ...promptOptions,
+        name: 'agent profile default',
+        flag: '--id',
+      });
+      return {
+        ...next,
+        id: profile.raw.id,
+        provider: profile.raw.provider,
+        model: profile.raw.model,
+        displayName: profile.raw.displayName,
+        label: profile.raw.label,
+        context: profile.raw.context,
+        defaultProfile: true,
+      };
+    }
+
+    if (action.value === 'update-current') {
+      const current = existingProfiles.find((profile) => profile.default) || existingProfiles[0];
+      next = {
+        ...next,
+        id: current.id,
+        context: next.context || current.context,
+        label: next.label || current.label,
+      };
+    }
+
+    if (action.value === 'create-new') {
+      const id = await promptText(`ID para el nuevo perfil ${role}`, {
+        ...promptOptions,
+        name: 'agent profile id',
+        flag: '--id',
+        placeholder: `${role}-gpt-55`,
+      });
+      next.id = id;
+      next.defaultProfile = options.defaultProfile === true;
+    }
+  }
+
+  if (!next.provider) {
+    const selectedProvider = await selectOption(`Elegí un provider para ${role}`, buildAgentProviderChoices(repoRoot, options), {
+      ...promptOptions,
+      name: 'agent provider',
+      flag: '--provider',
+    });
+    next.provider = selectedProvider.value;
+  }
+
+  if (!next.model) {
+    const selectedModel = await selectOption(`Elegí un modelo para ${role}`, buildAgentModelChoices(next.provider, role), {
+      ...promptOptions,
+      name: 'agent model',
+      flag: '--model',
+    });
+    if (selectedModel.value === 'custom') {
+      const model = await promptText(`Modelo custom para ${next.provider}`, {
+        ...promptOptions,
+        name: 'agent model',
+        flag: '--model',
+        placeholder: `${next.provider}-model-id`,
+      });
+      const displayName = await promptText('Nombre visible del modelo custom', {
+        ...promptOptions,
+        name: 'agent model display name',
+        flag: '--display-name',
+        initialValue: model,
+        required: false,
+      });
+      next.model = model;
+      next.displayName = next.displayName || displayName || model;
+    } else {
+      next.model = selectedModel.value;
+      next.displayName = next.displayName || selectedModel.raw.displayName;
+    }
+  }
+
+  return {
+    ...next,
+    interactiveResolved: true,
+  };
+}
+
 function formatAgentProfile(profile) {
   const lines = [
+    `ID: ${profile.id || 'default'}`,
     `Role: ${profile.role}`,
     `Provider: ${profile.provider}`,
     `Model: ${profile.model || '(not set)'}`,
     `Label: ${profile.label || '(not set)'}`,
+    `Display name: ${resolveAgentProfileDisplayName(profile) || '(not set)'}`,
+    `Default: ${profile.default === true ? 'yes' : 'no'}`,
     `Context: ${profile.context || '(not set)'}`,
     `Updated: ${profile.updated_at}`,
   ];
@@ -2193,7 +2666,9 @@ function formatAgentProfileList(profiles) {
     }
     const model = item.profile.model ? ` model=${item.profile.model}` : '';
     const label = item.profile.label ? ` label=${item.profile.label}` : '';
-    lines.push(`- ${item.role}: provider=${item.profile.provider}${model}${label}`);
+    const displayName = resolveAgentProfileDisplayName(item.profile);
+    const alternatives = item.profiles.length > 1 ? ` options=${item.profiles.length}` : '';
+    lines.push(`- ${item.role}: provider=${item.profile.provider}${model}${label} displayName=${displayName}${alternatives}`);
   }
   return `${lines.join('\n')}\n`;
 }
@@ -2213,22 +2688,156 @@ function formatAgentProfileDryRun(repoRoot, result) {
   ].join('\n');
 }
 
-function runAgent(repoRoot, options = {}) {
+function agentDoctorSymbol(status) {
+  if (status === 'error') return 'x';
+  if (status === 'warning') return '!';
+  return 'OK';
+}
+
+function formatAgentDoctorReport(report) {
+  const lines = [
+    'Quiver Agent Doctor',
+    '',
+    'Checks',
+  ];
+
+  if (report.checks.length === 0) {
+    lines.push('  ! No agent profiles configured');
+  }
+
+  for (const check of report.checks) {
+    const target = `${check.role}/${check.id}`;
+    const model = check.model || '(no model)';
+    const provider = check.provider || '(no provider)';
+    const defaultText = check.default ? ' default' : '';
+    lines.push(`  ${agentDoctorSymbol(check.status)} ${target}: provider=${provider} model=${model}${defaultText}`);
+    for (const finding of check.findings.filter((item) => item.severity !== 'info')) {
+      lines.push(`    - ${finding.severity}: ${finding.message}`);
+    }
+  }
+
+  lines.push('', 'Suggested fixes');
+  if (report.suggestedFixes.length === 0) {
+    lines.push('  OK No fixes suggested.');
+  } else {
+    for (const fix of report.suggestedFixes) {
+      lines.push(`  - ${fix}`);
+    }
+  }
+  lines.push('');
+  lines.push(`Summary: profiles=${report.summary.profiles} errors=${report.summary.errors} warnings=${report.summary.warnings} info=${report.summary.info}`);
+  lines.push('');
+  return `${lines.join('\n')}\n`;
+}
+
+function formatAgentRepairPlan(plan) {
+  const lines = [
+    'AI agent profile repair dry-run',
+    '- Writes: none',
+    '',
+    'Proposed changes',
+  ];
+
+  if (plan.changes.length === 0) {
+    lines.push('  OK No safe repairs found.');
+  }
+
+  for (const change of plan.changes) {
+    lines.push(`  - ${change.role}/${change.profileId}: ${change.reason}`);
+    lines.push(`    Before: model=${change.before.model || '(not set)'} displayName=${change.before.displayName || '(not set)'}`);
+    lines.push(`    After: model=${change.after.model || '(not set)'} displayName=${change.after.displayName || '(not set)'}`);
+  }
+
+  lines.push('');
+  return `${lines.join('\n')}\n`;
+}
+
+function buildModelsListReport(options = {}) {
+  const providerFilter = String(options.provider || '').trim().toLowerCase();
+  const providers = providerFilter
+    ? [listCatalogProviders().find((provider) => provider.id === providerFilter)].filter(Boolean)
+    : listCatalogProviders();
+
+  if (providerFilter && providers.length === 0) {
+    throw new Error(formatError(`unsupported provider filter '${options.provider}'. Supported providers: ${listCatalogProviders().map((provider) => provider.id).join(', ')}.`));
+  }
+
+  return {
+    catalogVersion: MODEL_CATALOG_VERSION,
+    lastUpdated: MODEL_CATALOG_LAST_UPDATED,
+    note: 'Models are known by Quiver. This does not guarantee provider account access.',
+    providers: providers.map((provider) => ({
+      id: provider.id,
+      displayName: provider.displayName,
+      models: getKnownModelsForProvider(provider.id).map((model) => ({
+        id: model.id,
+        displayName: model.displayName,
+        recommendedFor: model.recommendedFor,
+        costTier: model.costTier,
+        qualityTier: model.qualityTier,
+        stability: model.stability,
+        custom: model.custom === true,
+      })),
+    })),
+  };
+}
+
+function formatModelsListReport(report) {
+  const lines = [
+    'AI models known by Quiver',
+    `Catalog version: ${report.catalogVersion}`,
+    `Last updated: ${report.lastUpdated}`,
+    'Note: Models are known by Quiver; provider account access is not guaranteed.',
+    '',
+  ];
+
+  for (const provider of report.providers) {
+    lines.push(`${provider.displayName} (${provider.id})`);
+    for (const model of provider.models) {
+      const roles = model.recommendedFor.length > 0 ? model.recommendedFor.join(', ') : 'custom/manual';
+      lines.push(`  - ${model.id} (${model.displayName})`);
+      lines.push(`    roles: ${roles}`);
+      lines.push(`    cost=${model.costTier} quality=${model.qualityTier} stability=${model.stability}`);
+    }
+    lines.push('');
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function runModelsList(options = {}) {
+  const report = buildModelsListReport({
+    provider: options.provider,
+  });
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  } else {
+    process.stdout.write(formatModelsListReport(report));
+  }
+  return {
+    task: 'models',
+    command: 'list',
+    report,
+  };
+}
+
+async function runAgent(repoRoot, options = {}) {
   const command = String(options.command || '').trim().toLowerCase();
 
   if (command === 'set') {
     if (!options.role) {
-      throw new Error(formatError('missing agent role. Use: npx create-quiver ai agent set <planner|executor|reviewer|doctor> --provider <provider>'));
-    }
-    if (!options.provider) {
-      throw new Error(formatError('ai agent set requires --provider. Supported providers: codex, claude, gemini.'));
+      throw new Error(formatError('missing agent role. Use: npx create-quiver ai agent set <planner|executor|reviewer|doctor> --provider <provider> --model <model>'));
     }
+    const profileOptions = await resolveInteractiveAgentSetOptions(repoRoot, options);
     if (options.dryRun) {
-      const preview = buildAgentProfileState(repoRoot, options.role, {
-        context: options.context,
-        label: options.label,
-        model: options.model,
-        provider: options.provider,
+      const preview = buildAgentProfileState(repoRoot, profileOptions.role, {
+        context: profileOptions.context,
+        default: profileOptions.defaultProfile,
+        displayName: profileOptions.displayName,
+        id: profileOptions.id,
+        label: profileOptions.label,
+        model: profileOptions.model,
+        provider: profileOptions.provider,
       });
       process.stdout.write(formatAgentProfileDryRun(repoRoot, preview));
       return {
@@ -2239,11 +2848,35 @@ function runAgent(repoRoot, options = {}) {
         filePath: path.relative(repoRoot, preview.filePath).split(path.sep).join('/'),
       };
     }
-    const result = setAgentProfile(repoRoot, options.role, {
-      context: options.context,
-      label: options.label,
-      model: options.model,
-      provider: options.provider,
+    if (profileOptions.interactiveResolved === true) {
+      const preview = buildAgentProfileState(repoRoot, profileOptions.role, {
+        context: profileOptions.context,
+        default: profileOptions.defaultProfile,
+        displayName: profileOptions.displayName,
+        id: profileOptions.id,
+        label: profileOptions.label,
+        model: profileOptions.model,
+        provider: profileOptions.provider,
+      });
+      const ux = createCommandUx(profileOptions);
+      ux.summary([
+        { label: 'Role', value: preview.profile.role },
+        { label: 'Provider', value: preview.profile.provider },
+        { label: 'Model', value: preview.profile.model || '(not set)' },
+        { label: 'Display name', value: resolveAgentProfileDisplayName(preview.profile) || '(not set)' },
+        { label: 'Default', value: preview.profile.default === true ? 'yes' : 'no' },
+      ], {
+        title: 'Profile to save',
+      });
+    }
+    const result = setAgentProfile(repoRoot, profileOptions.role, {
+      context: profileOptions.context,
+      default: profileOptions.defaultProfile,
+      displayName: profileOptions.displayName,
+      id: profileOptions.id,
+      label: profileOptions.label,
+      model: profileOptions.model,
+      provider: profileOptions.provider,
     });
     process.stdout.write('AI agent profile saved\n');
     process.stdout.write(formatAgentProfile(result.profile));
@@ -2260,13 +2893,17 @@ function runAgent(repoRoot, options = {}) {
     if (!options.role) {
       throw new Error(formatError('missing agent role. Use: npx create-quiver ai agent show <planner|executor|reviewer|doctor>'));
     }
-    const profile = getAgentProfile(repoRoot, options.role);
+    const profile = options.id
+      ? getAgentProfileById(repoRoot, options.role, options.id)
+      : getAgentProfile(repoRoot, options.role);
     if (!profile) {
       throw new Error(formatActionableError({
-        failure: `agent profile '${options.role}' is not configured.`,
+        failure: options.id
+          ? `agent profile '${options.role}/${options.id}' is not configured.`
+          : `agent profile '${options.role}' is not configured.`,
         impact: 'Quiver will fall back to default provider behavior and may use the wrong model/cost profile.',
-        fix: `Configure the ${options.role} profile with a supported provider and optional model label.`,
-        nextCommand: `npx create-quiver ai agent set ${options.role} --provider <provider> --model <label>`,
+        fix: `Configure the ${options.role} profile with a supported provider and technical model id.`,
+        nextCommand: `npx create-quiver ai agent set ${options.role} --provider <provider> --model <model-id>`,
       }));
     }
     process.stdout.write(formatAgentProfile(profile));
@@ -2288,7 +2925,44 @@ function runAgent(repoRoot, options = {}) {
     };
   }
 
-  throw new Error(formatError(`unsupported ai agent subcommand: ${command}. Supported tasks: set, list, show`));
+  if (command === 'doctor') {
+    const report = buildAgentProfileDoctorReport(repoRoot);
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    } else {
+      process.stdout.write(formatAgentDoctorReport(report));
+    }
+    if (report.summary.errors > 0) {
+      process.exitCode = 1;
+    }
+    return {
+      task: 'agent',
+      command,
+      report,
+    };
+  }
+
+  if (command === 'repair') {
+    if (options.dryRun !== true) {
+      throw new Error(formatError('ai agent repair only supports --dry-run for now. No files were written.'));
+    }
+    const plan = buildAgentProfileRepairPlan(repoRoot, {
+      includeState: options.json === true,
+    });
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(plan, null, 2)}\n`);
+    } else {
+      process.stdout.write(formatAgentRepairPlan(plan));
+    }
+    return {
+      task: 'agent',
+      command,
+      dryRun: true,
+      plan,
+    };
+  }
+
+  throw new Error(formatError(`unsupported ai agent subcommand: ${command}. Supported tasks: set, list, show, doctor, repair`));
 }
 
 async function runGitHubTask(repoRoot, options = {}, mode = 'pr') {
@@ -2324,20 +2998,32 @@ async function runGitHubTask(repoRoot, options = {}, mode = 'pr') {
 async function runPr(repoRoot, options = {}) {
   const dryRun = options.dryRun === true;
   const create = options.create === true;
+  const ux = createCommandUx(options);
+  const showProgress = create && !dryRun && shouldShowHumanProgress(ux, options);
+  if (showProgress) {
+    ux.heading('Creando PR con gh');
+  }
   let preflight;
 
   try {
-    preflight = await (options.preflightFn || preflightGitHubPr)(repoRoot, {
-      remote: options.remote,
-      sshHostAlias: options.sshHostAlias,
-      identityFile: options.identityFile,
-      gitFlowGuidePath: options.gitFlowGuidePath,
-      ghCommand: options.ghCommand,
-      ghProbe: options.ghProbe,
-      ghAuthProbe: options.ghAuthProbe,
-      ghProbeArgs: options.ghProbeArgs,
-      ghAuthArgs: options.ghAuthArgs,
-      blockedBranches: options.blockedBranches,
+    preflight = await runProviderWithProgress({
+      ux,
+      enabled: showProgress,
+      message: 'Ejecutando preflight de GitHub...',
+      successMessage: 'Preflight de GitHub listo',
+      failureMessage: 'Falló preflight de GitHub',
+      run: () => (options.preflightFn || preflightGitHubPr)(repoRoot, {
+        remote: options.remote,
+        sshHostAlias: options.sshHostAlias,
+        identityFile: options.identityFile,
+        gitFlowGuidePath: options.gitFlowGuidePath,
+        ghCommand: options.ghCommand,
+        ghProbe: options.ghProbe,
+        ghAuthProbe: options.ghAuthProbe,
+        ghProbeArgs: options.ghProbeArgs,
+        ghAuthArgs: options.ghAuthArgs,
+        blockedBranches: options.blockedBranches,
+      }),
     });
   } catch (error) {
     throw annotateGitHubError(error, 'pr');
@@ -2352,6 +3038,9 @@ async function runPr(repoRoot, options = {}) {
       prBodyPath: options.prBodyPath,
       title: options.title,
     });
+    if (showProgress) {
+      ux.check('Cuerpo del PR preparado');
+    }
   } catch (error) {
     throw annotateGitHubError(error, 'pr');
   }
@@ -2396,8 +3085,15 @@ async function runPr(repoRoot, options = {}) {
 
   let result;
   try {
-    result = runGhPrCreate(plan, {
-      ghCreateRunner: options.ghCreateRunner,
+    result = await runProviderWithProgress({
+      ux,
+      enabled: showProgress,
+      message: 'Creando PR en GitHub...',
+      successMessage: 'PR creado',
+      failureMessage: 'Falló creación del PR',
+      run: () => runGhPrCreate(plan, {
+        ghCreateRunner: options.ghCreateRunner,
+      }),
     });
   } catch (error) {
     throw annotateGitHubError(error, 'pr');
@@ -2435,6 +3131,7 @@ module.exports = {
   formatSpecDryRunReport,
   normalizeTimeout,
   readTextFile,
+  resolveInteractiveAgentSetOptions,
   runAgent,
   runActiveSlice,
   runDoctor,
@@ -2443,6 +3140,7 @@ module.exports = {
   runLifecycleResume,
   runLifecycleRun,
   runLifecycleStatus,
+  runModelsList,
   runExport,
   runInspect,
   runPromptSlice,