create-quiver 0.15.0 → 0.15.2

package/src/create-quiver/lib/agent-profiles.js

@@ -2,6 +2,8 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const { assertSupportedProvider, formatProviderList } = require('./ai/providers');
+const { normalizeModelSelection } = require('./ai/model-catalog');
+const { preflightProvider } = require('./ai/preflight');
 const { quiverInternalPaths } = require('./init-layout');
 
 const AGENT_PROFILE_ROLES = Object.freeze(['planner', 'executor', 'reviewer', 'doctor']);
@@ -87,6 +89,11 @@ function normalizeStoredProfile(profile, role, fallbackId = 'default') {
     label: normalizeOptionalText(profile?.label, 'label'),
     displayName: normalizeOptionalText(profile?.displayName || profile?.display_name, 'displayName'),
     context: normalizeOptionalText(profile?.context, 'context'),
+    modelSource: normalizeOptionalText(profile?.modelSource || profile?.model_source, 'modelSource'),
+    modelAlias: normalizeOptionalText(profile?.modelAlias || profile?.model_alias, 'modelAlias'),
+    validation_status: normalizeOptionalText(profile?.validation_status || profile?.validationStatus, 'validation_status'),
+    validated_at: normalizeOptionalText(profile?.validated_at || profile?.validatedAt, 'validated_at'),
+    validation_error: normalizeOptionalText(profile?.validation_error || profile?.validationError, 'validation_error'),
     default: profile?.default === true,
     updated_at: profile?.updated_at || '',
   };
@@ -181,25 +188,44 @@ function setAgentProfile(projectRoot, role, options = {}) {
 function buildAgentProfileState(projectRoot, role, options = {}) {
   const normalizedRole = normalizeAgentProfileRole(role);
   const provider = assertSupportedProvider(options.provider);
-  const model = normalizeOptionalText(options.model, 'model');
+  const rawModel = normalizeOptionalText(options.model, 'model');
   const label = normalizeOptionalText(options.label, 'label');
-  const displayName = normalizeOptionalText(options.displayName || options.display_name, 'displayName');
+  const rawDisplayName = normalizeOptionalText(options.displayName || options.display_name, 'displayName');
   const context = normalizeOptionalText(options.context, 'context');
   const state = readAgentProfiles(projectRoot);
   const currentProfiles = getAgentProfilesForRole(projectRoot, normalizedRole);
   const currentDefault = currentProfiles.find((profile) => profile.default) || currentProfiles[0] || {};
-  const id = normalizeProfileId(options.id || currentDefault.id || label || model || provider);
+  const modelSelection = rawModel
+    ? normalizeModelSelection(provider, rawModel, { displayName: rawDisplayName })
+    : null;
+  const id = normalizeProfileId(options.id || currentDefault.id || label || modelSelection?.model || rawModel || provider);
   const current = currentProfiles.find((profile) => profile.id === id) || {};
+  const model = modelSelection?.model || current.model || '';
+  const displayName = rawDisplayName
+    || modelSelection?.displayName
+    || current.displayName
+    || model
+    || label
+    || provider;
   const now = options.now instanceof Date ? options.now.toISOString() : new Date().toISOString();
   const shouldBeDefault = options.default === true || currentProfiles.length === 0 || (options.default !== false && current.default === true);
+  const modelSource = modelSelection?.modelSource || current.modelSource || (model ? 'custom' : '');
+  const modelAlias = modelSelection && modelSelection.input && modelSelection.input !== model
+    ? modelSelection.input
+    : (current.modelAlias || '');
   const profile = {
     id,
     role: normalizedRole,
     provider,
     model: model || current.model || '',
     label: label || current.label || '',
-    displayName: displayName || current.displayName || model || label || provider,
+    displayName,
     context: context || current.context || '',
+    modelSource,
+    modelAlias,
+    validation_status: current.validation_status || (model ? 'not-tested' : ''),
+    validated_at: current.validated_at || '',
+    validation_error: current.validation_error || '',
     default: shouldBeDefault,
     updated_at: now,
   };
@@ -243,10 +269,312 @@ function resolveProfileProvider(projectRoot, role, fallbackProvider) {
   return assertSupportedProvider(fallbackProvider);
 }
 
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function rawText(value) {
+  return String(value || '').trim();
+}
+
+function rawDisplayName(profile, role) {
+  return rawText(profile.displayName || profile.display_name || profile.model || profile.provider || role);
+}
+
+function collectRawAgentProfileEntries(state) {
+  const entries = [];
+  for (const role of AGENT_PROFILE_ROLES) {
+    const setKey = profileSetKey(role);
+    const setProfiles = Array.isArray(state.profile_sets?.[setKey]) ? state.profile_sets[setKey] : [];
+    if (setProfiles.length > 0) {
+      setProfiles.forEach((profile, index) => {
+        entries.push({
+          role,
+          profile,
+          id: normalizeProfileId(profile?.id || profile?.label, index === 0 ? 'default' : `${role}-${index + 1}`),
+          source: 'profile_sets',
+          setKey,
+          index,
+        });
+      });
+      continue;
+    }
+
+    if (state.profiles?.[role]) {
+      entries.push({
+        role,
+        profile: state.profiles[role],
+        id: normalizeProfileId(state.profiles[role]?.id || state.profiles[role]?.label, 'default'),
+        source: 'profiles',
+        index: null,
+      });
+    }
+  }
+  return entries;
+}
+
+function createAgentProfileFinding(severity, code, message, entry, extra = {}) {
+  return {
+    severity,
+    code,
+    message,
+    role: entry.role,
+    profileId: entry.id,
+    fix: extra.fix || '',
+    before: extra.before,
+    after: extra.after,
+  };
+}
+
+function classifyAgentProfileEntry(projectRoot, entry, options = {}) {
+  const findings = [];
+  const profile = entry.profile || {};
+  const providerInput = rawText(profile.provider).toLowerCase();
+  const modelInput = rawText(profile.model);
+  const displayName = rawDisplayName(profile, entry.role);
+  let provider = providerInput;
+  let status = 'ok';
+
+  if (!providerInput) {
+    findings.push(createAgentProfileFinding(
+      'error',
+      'missing-provider',
+      `Profile ${entry.role}/${entry.id} is missing provider.`,
+      entry,
+      { fix: `npx create-quiver ai agent set ${entry.role} --provider <provider> --model <model>` },
+    ));
+  } else {
+    try {
+      provider = assertSupportedProvider(providerInput);
+      const runPreflight = options.checkProviderCli !== false;
+      if (runPreflight) {
+        const preflight = options.preflightProvider || preflightProvider;
+        try {
+          preflight(provider, {
+            cwd: projectRoot,
+            probe: options.providerProbe,
+            probeArgs: options.providerProbeArgs,
+          });
+        } catch (error) {
+          findings.push(createAgentProfileFinding(
+            'warning',
+            error && error.code === 'MISSING_PROVIDER_CLI' ? 'provider-cli-missing' : 'provider-cli-unverified',
+            `Provider CLI for '${provider}' could not be verified.`,
+            entry,
+            { fix: `Install and authenticate the ${provider} CLI, then rerun npx create-quiver ai agent doctor.` },
+          ));
+        }
+      }
+    } catch (error) {
+      findings.push(createAgentProfileFinding(
+        'error',
+        'unsupported-provider',
+        `Profile ${entry.role}/${entry.id} uses unsupported provider '${profile.provider}'.`,
+        entry,
+        { fix: `Use one of: ${formatProviderList()}.` },
+      ));
+      provider = providerInput;
+    }
+  }
+
+  if (!modelInput) {
+    findings.push(createAgentProfileFinding(
+      'warning',
+      'missing-model',
+      `Profile ${entry.role}/${entry.id} has no model selected.`,
+      entry,
+      { fix: `npx create-quiver ai agent set ${entry.role} --provider ${provider || '<provider>'} --model <model>` },
+    ));
+  } else if (providerInput && findings.every((finding) => finding.code !== 'unsupported-provider')) {
+    const modelSelection = normalizeModelSelection(provider, modelInput, {
+      displayName: rawText(profile.displayName || profile.display_name),
+    });
+    if (modelSelection.modelSource === 'catalog' && modelSelection.model !== modelInput) {
+      findings.push(createAgentProfileFinding(
+        'warning',
+        'display-model-alias',
+        `Profile ${entry.role}/${entry.id} stores display alias '${modelInput}' as the technical model id.`,
+        entry,
+        {
+          fix: 'Run npx create-quiver ai agent repair --dry-run to preview the normalized profile.',
+          before: { model: modelInput, displayName: rawText(profile.displayName || profile.display_name) },
+          after: { model: modelSelection.model, displayName: modelSelection.displayName },
+        },
+      ));
+    }
+    if (modelSelection.modelSource === 'custom') {
+      const validationStatus = rawText(profile.validation_status || profile.validationStatus);
+      if (!['validated', 'ok', 'passed'].includes(validationStatus.toLowerCase())) {
+        findings.push(createAgentProfileFinding(
+          'warning',
+          'custom-model-unvalidated',
+          `Profile ${entry.role}/${entry.id} uses custom model '${modelInput}' without live validation evidence.`,
+          entry,
+          { fix: `Run a dry-run or provider smoke with ${provider} before using this profile in automation.` },
+        ));
+      }
+    }
+  }
+
+  if (profile.default === true) {
+    findings.push(createAgentProfileFinding(
+      'info',
+      'default-profile',
+      `Profile ${entry.role}/${entry.id} is the default ${entry.role} profile.`,
+      entry,
+    ));
+  }
+
+  if (findings.some((finding) => finding.severity === 'error')) status = 'error';
+  else if (findings.some((finding) => finding.severity === 'warning')) status = 'warning';
+
+  return {
+    role: entry.role,
+    id: entry.id,
+    source: entry.source,
+    provider,
+    model: modelInput,
+    displayName,
+    default: profile.default === true,
+    status,
+    findings,
+  };
+}
+
+function addDuplicateDisplayNameFindings(checks) {
+  const groups = new Map();
+  for (const check of checks) {
+    const key = `${check.role}:${rawText(check.displayName).toLowerCase()}`;
+    if (!check.displayName) continue;
+    const group = groups.get(key) || [];
+    group.push(check);
+    groups.set(key, group);
+  }
+
+  for (const group of groups.values()) {
+    if (group.length < 2) continue;
+    const ids = group.map((item) => `${item.role}/${item.id}`).join(', ');
+    for (const check of group) {
+      check.findings.push({
+        severity: 'warning',
+        code: 'duplicate-display-name',
+        message: `Display name '${check.displayName}' is shared by ${ids}.`,
+        role: check.role,
+        profileId: check.id,
+        fix: 'Use --display-name or --id to make selector entries easier to distinguish.',
+      });
+      if (check.status !== 'error') check.status = 'warning';
+    }
+  }
+}
+
+function buildAgentProfileDoctorReport(projectRoot, options = {}) {
+  const state = readAgentProfiles(projectRoot);
+  const entries = collectRawAgentProfileEntries(state);
+  const checks = entries.map((entry) => classifyAgentProfileEntry(projectRoot, entry, options));
+  addDuplicateDisplayNameFindings(checks);
+  const findings = checks.flatMap((check) => check.findings);
+  const errors = findings.filter((finding) => finding.severity === 'error').length;
+  const warnings = findings.filter((finding) => finding.severity === 'warning').length;
+  const info = findings.filter((finding) => finding.severity === 'info').length;
+  const suggestedFixes = Array.from(new Set(findings
+    .map((finding) => finding.fix)
+    .filter(Boolean)));
+
+  return {
+    ok: errors === 0,
+    summary: {
+      profiles: checks.length,
+      defaults: checks.filter((check) => check.default).length,
+      errors,
+      warnings,
+      info,
+    },
+    checks,
+    findings,
+    suggestedFixes,
+  };
+}
+
+function repairProfileObject(profile, provider, modelSelection) {
+  const before = {
+    model: rawText(profile.model),
+    displayName: rawText(profile.displayName || profile.display_name),
+    modelSource: rawText(profile.modelSource || profile.model_source),
+    modelAlias: rawText(profile.modelAlias || profile.model_alias),
+    validation_status: rawText(profile.validation_status || profile.validationStatus),
+  };
+  const after = {
+    ...before,
+    model: modelSelection.model,
+    displayName: before.displayName || modelSelection.displayName,
+    modelSource: 'catalog',
+    modelAlias: before.model,
+    validation_status: before.validation_status || 'not-tested',
+  };
+
+  profile.model = after.model;
+  profile.displayName = after.displayName;
+  profile.modelSource = after.modelSource;
+  profile.modelAlias = after.modelAlias;
+  profile.validation_status = after.validation_status;
+  return { before, after, provider };
+}
+
+function buildAgentProfileRepairPlan(projectRoot, options = {}) {
+  const state = readAgentProfiles(projectRoot);
+  const nextState = cloneJson(state);
+  const entries = collectRawAgentProfileEntries(state);
+  const changes = [];
+
+  for (const entry of entries) {
+    const profile = entry.profile || {};
+    const providerInput = rawText(profile.provider).toLowerCase();
+    const modelInput = rawText(profile.model);
+    if (!providerInput || !modelInput) continue;
+
+    let provider;
+    try {
+      provider = assertSupportedProvider(providerInput);
+    } catch (error) {
+      continue;
+    }
+
+    const modelSelection = normalizeModelSelection(provider, modelInput, {
+      displayName: rawText(profile.displayName || profile.display_name),
+    });
+    if (modelSelection.modelSource !== 'catalog' || modelSelection.model === modelInput) {
+      continue;
+    }
+
+    const target = entry.source === 'profile_sets'
+      ? nextState.profile_sets[entry.setKey][entry.index]
+      : nextState.profiles[entry.role];
+    const repair = repairProfileObject(target, provider, modelSelection);
+    changes.push({
+      role: entry.role,
+      profileId: entry.id,
+      provider,
+      reason: 'display-model-alias',
+      before: repair.before,
+      after: repair.after,
+    });
+  }
+
+  return {
+    dryRun: true,
+    wouldWrite: false,
+    changes,
+    nextState: options.includeState === true ? nextState : undefined,
+  };
+}
+
 module.exports = {
   AGENT_PROFILE_ROLES,
   PROFILE_STATE_VERSION,
   agentProfilesPath,
+  buildAgentProfileDoctorReport,
+  buildAgentProfileRepairPlan,
   getAgentProfileById,
   getAgentProfilesForRole,
   resolveAgentProfileDisplayName,

package/src/create-quiver/lib/ai/approval-candidates.js

@@ -0,0 +1,86 @@
+const { buildPlannerApprovalCandidates } = require('../approvals');
+const { buildTechnicalPlanApprovalCandidates } = require('./plan-review');
+
+function buildApprovalCandidateReport(projectRoot, phase) {
+  return phase === 'technical-plan'
+    ? buildTechnicalPlanApprovalCandidates(projectRoot)
+    : buildPlannerApprovalCandidates(projectRoot, phase);
+}
+
+function formatReviewSummary(review) {
+  if (!review || !review.recommendation) {
+    return '';
+  }
+
+  const parts = [`review=${review.recommendation}`];
+  if (review.blocking) {
+    parts.push('blocking');
+  }
+  if (review.required_fixes_count) {
+    parts.push(`required fixes=${review.required_fixes_count}`);
+  }
+  if (review.optional_hardening_count) {
+    parts.push(`optional=${review.optional_hardening_count}`);
+  }
+  if (review.risks_count) {
+    parts.push(`risks=${review.risks_count}`);
+  }
+  return parts.join(', ');
+}
+
+function formatCandidateSummary(candidate) {
+  if (!candidate) {
+    return '';
+  }
+
+  const parts = [
+    candidate.label,
+    candidate.current ? 'current' : 'history',
+    candidate.approvable ? 'approvable' : 'blocked',
+    candidate.reason,
+    formatReviewSummary(candidate.review),
+  ].filter(Boolean);
+  return parts.join(', ');
+}
+
+function approvalCandidateCommand(report, fallback = 'npx create-quiver ai approvals') {
+  if (report?.recommended?.next_command) {
+    return report.recommended.next_command;
+  }
+  if (report?.current?.next_command) {
+    return report.current.next_command;
+  }
+  return report?.next_command || fallback;
+}
+
+function formatApprovalDecisionLines(report) {
+  const lines = [];
+  if (!report || !Array.isArray(report.candidates)) {
+    return lines;
+  }
+
+  lines.push(`Candidates: ${report.candidates.length}`);
+  if (report.latest_version) {
+    lines.push(`Latest draft: v${report.latest_version}`);
+  }
+  if (report.current) {
+    lines.push(`Current candidate: ${formatCandidateSummary(report.current)}`);
+  }
+  if (report.recommended) {
+    lines.push(`Recommended approval: ${report.recommended.next_command}`);
+  } else if (report.next_command) {
+    lines.push(`Recommended next command: ${report.next_command}`);
+  }
+  if (report.review?.status) {
+    lines.push(`Review status: ${report.review.status}`);
+  }
+  return lines;
+}
+
+module.exports = {
+  approvalCandidateCommand,
+  buildApprovalCandidateReport,
+  formatApprovalDecisionLines,
+  formatCandidateSummary,
+  formatReviewSummary,
+};

package/src/create-quiver/lib/ai/execution-plan.js

@@ -12,6 +12,7 @@ const { branchDelete, runGit, statusPorcelain, worktreeAdd, worktreePrune, workt
 const { withLock } = require('../locks');
 const { safeBranchName, worktreesRootForRepo } = require('../slice');
 const { buildGraph, computeLevels, detectFileConflicts, isFoundationSliceId, readAllSlices, topoSort, SliceGraphError } = require('../slice-graph');
+const { resolveProviderModelSelection } = require('./providers');
 const { runExecuteSlice } = require('./executor');
 
 const EXCLUDED_STATUSES = new Set(['completed', 'skipped', 'cancelled']);
@@ -641,13 +642,17 @@ async function runExecutePlan(repoRoot, options = {}) {
   const executionMode = normalizeExecutionMode(options.mode || options.executionMode);
   const runtimeProfile = resolveExecutorRuntimeProfile(repoRoot, options);
   const provider = runtimeProfile.provider;
+  const explicitModel = String(options.model || '').trim();
+  const resolvedModel = runtimeProfile.model
+    ? resolveProviderModelSelection(provider, runtimeProfile.model).model
+    : '';
   const resolvedOptions = {
     ...options,
     mode: executionMode,
-    model: runtimeProfile.model,
+    model: explicitModel ? resolvedModel : undefined,
     provider,
     profile: runtimeProfile,
-    resolvedModel: runtimeProfile.model,
+    resolvedModel,
     resolvedProvider: provider,
   };
 

package/src/create-quiver/lib/ai/executor.js

@@ -86,6 +86,13 @@ function resolveExecutorRuntimeProfile(repoRoot, role, options = {}) {
   };
 }
 
+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;
@@ -955,7 +962,7 @@ async function runExecuteSlice(repoRoot, options = {}) {
       prompt,
       cwd: canonicalRepoRoot,
       timeoutMs,
-      model: runtimeProfile.model,
+      ...runtimeModelExecutionOptions(runtimeProfile, options),
       enforceModelSelection: false,
     });
   } catch (error) {
@@ -1028,7 +1035,7 @@ async function runExecuteSlice(repoRoot, options = {}) {
         tempRoot: options.tempRoot,
         tempFileName: options.tempFileName,
         tempFilePrefix: options.tempFilePrefix,
-        model: runtimeProfile.model,
+      ...runtimeModelExecutionOptions(runtimeProfile, options),
         enforceModelSelection: Boolean(runtimeProfile.model),
       }),
     });