create-quiver 0.14.1 → 0.15.0

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

@@ -4,11 +4,20 @@ const cp = require('node:child_process');
 
 const { buildContextPackMetadata, normalizeRole } = require('./context-packs');
 const { buildProviderInvocation, runProvider } = require('./providers');
-const { resolveProfileProvider } = require('../agent-profiles');
+const {
+  getAgentProfile,
+  getAgentProfileById,
+  getAgentProfilesForRole,
+  resolveAgentProfileDisplayName,
+  resolveProfileProvider,
+} = require('../agent-profiles');
+const { selectOption } = require('../cli/selectors');
+const { createUx } = require('../cli/ux');
 const { currentBranch, runGit } = require('../git');
 const { redactSecrets, truncateText } = require('../evidence');
 const { captureWorktreeSnapshot, validateScopeSnapshot } = require('../scope');
 const { resolveSliceContext } = require('../slice');
+const { buildGraph, readAllSlices, topoSort } = require('../slice-graph');
 const { validateProjectRelativePaths } = require('../paths');
 
 const DEFAULT_EXECUTE_PROVIDER = 'codex';
@@ -49,6 +58,208 @@ function normalizeTimeout(timeoutMs) {
   return parsed;
 }
 
+function resolveExecutorRuntimeProfile(repoRoot, role, options = {}) {
+  const explicitProvider = options.providerExplicit === true || (options.provider && options.providerExplicit !== false);
+  const explicitModel = String(options.model || '').trim();
+
+  if (explicitProvider) {
+    const provider = String(options.provider || DEFAULT_EXECUTE_PROVIDER).trim().toLowerCase();
+    return {
+      provider,
+      model: explicitModel,
+      displayName: explicitModel || provider,
+      profile: null,
+    };
+  }
+
+  const profile = options.executorProfile
+    ? getAgentProfileById(repoRoot, role, options.executorProfile)
+    : getAgentProfile(repoRoot, role);
+  const provider = profile?.provider || resolveProfileProvider(repoRoot, role, DEFAULT_EXECUTE_PROVIDER);
+  const model = explicitModel || profile?.model || '';
+
+  return {
+    provider,
+    model,
+    displayName: profile ? resolveAgentProfileDisplayName(profile) : (model || provider),
+    profile,
+  };
+}
+
+function createCommandUx(options = {}) {
+  if (options.ux) {
+    return options.ux;
+  }
+
+  return createUx({
+    env: options.env || process.env,
+    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 selectorOptions(options = {}) {
+  return {
+    defaultValue: options.defaultValue,
+    env: options.env || process.env,
+    flag: options.flag,
+    interactive: options.interactive,
+    promptSelect: options.promptSelect,
+    prompts: options.prompts,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    stderrIsTTY: options.stderrIsTTY,
+  };
+}
+
+async function resolveInteractiveExecutorProfile(repoRoot, role, options = {}) {
+  if (options.providerExplicit === true || options.provider || options.executorProfile || options.interactive !== true) {
+    return options.executorProfile || '';
+  }
+
+  const profiles = getAgentProfilesForRole(repoRoot, role);
+  if (profiles.length <= 1) {
+    return options.executorProfile || '';
+  }
+
+  const selected = await selectOption(
+    '¿Qué Executor querés usar?',
+    profiles.map((profile) => ({
+      label: resolveAgentProfileDisplayName(profile),
+      value: profile.id,
+      hint: `${profile.provider}${profile.model ? ` / ${profile.model}` : ''}`,
+    })),
+    selectorOptions({
+      ...options,
+      defaultValue: profiles.find((profile) => profile.default)?.id || profiles[0].id,
+      flag: '--executor',
+    }),
+  );
+
+  return selected.value;
+}
+
+function isCompletedStatus(status) {
+  return ['completed', 'done', 'skipped', 'cancelled'].includes(String(status || '').trim().toLowerCase());
+}
+
+function readySliceOptions(repoRoot) {
+  const allSlices = readAllSlices(repoRoot);
+  const graph = buildGraph(allSlices);
+  topoSort(graph);
+  const pending = graph.nodes.filter((node) => !isCompletedStatus(node.status));
+  const pendingRefs = new Set(pending.map((node) => node.ref));
+  const completedRefs = new Set(graph.nodes.filter((node) => isCompletedStatus(node.status)).map((node) => node.ref));
+  const pendingFoundationBySpec = new Set(pending
+    .filter((node) => node.sliceId === 'slice-00' || String(node.sliceId || '').startsWith('slice-00-'))
+    .map((node) => node.specSlug));
+  const incomingByRef = new Map();
+
+  for (const edge of graph.edges) {
+    if (!incomingByRef.has(edge.to)) {
+      incomingByRef.set(edge.to, []);
+    }
+    incomingByRef.get(edge.to).push(edge.from);
+  }
+
+  return pending
+    .filter((node) => {
+      if (pendingFoundationBySpec.has(node.specSlug) && !(node.sliceId === 'slice-00' || String(node.sliceId || '').startsWith('slice-00-'))) {
+        return false;
+      }
+      const incoming = incomingByRef.get(node.ref) || [];
+      return incoming.every((depRef) => completedRefs.has(depRef) || !pendingRefs.has(depRef));
+    })
+    .sort((left, right) => String(left.ref).localeCompare(String(right.ref)))
+    .map((node) => ({
+      label: `${node.ref} [${node.status || 'draft'}]`,
+      value: toRelativePath(repoRoot, node.slicePath),
+      hint: node.title || node.sliceId,
+    }));
+}
+
+async function resolveInteractiveSliceInput(repoRoot, options = {}) {
+  if (options.slice) {
+    return options.slice;
+  }
+
+  if (options.interactive !== true) {
+    throw new Error(formatError('missing required --slice path for ai execute-slice'));
+  }
+
+  const optionsForSlices = readySliceOptions(repoRoot);
+  if (optionsForSlices.length === 0) {
+    throw new Error(formatError('no ready slices found for interactive execution. Run `npx create-quiver ai execute-plan --dry-run` to inspect dependencies and blockers.'));
+  }
+
+  const selected = await selectOption(
+    '¿Qué slice querés ejecutar?',
+    optionsForSlices,
+    selectorOptions({
+      ...options,
+      defaultValue: optionsForSlices.length === 1 ? optionsForSlices[0].value : undefined,
+      flag: '--slice',
+    }),
+  );
+  return selected.value;
+}
+
+function shouldShowHumanProgress(ux, options = {}) {
+  return options.progress !== false
+    && options.dryRun !== true
+    && ux?.mode?.decoration === true;
+}
+
+function writeProgressChecks(ux, enabled, title, checks = []) {
+  if (!enabled) {
+    return;
+  }
+  ux.heading(title);
+  for (const check of checks) {
+    ux.check(check);
+  }
+}
+
+async function runWithProgress({ ux, enabled, message, successMessage, failureMessage, run }) {
+  if (!enabled) {
+    return run();
+  }
+
+  return ux.withSpinner(message, run, {
+    successMessage,
+    failureMessage,
+  });
+}
+
+async function runProviderWithProgress({ ux, enabled, 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;
+  }
+
+  return runWithProgress({
+    ux,
+    enabled,
+    message: 'Ejecutando agente...',
+    successMessage: 'Agente finalizado',
+    failureMessage: 'Fallo ejecutando agente',
+    run: runAndFailOnProviderResult,
+  });
+}
+
 function toRelativePath(repoRoot, absolutePath) {
   return path.relative(repoRoot, absolutePath).split(path.sep).join('/');
 }
@@ -378,11 +589,17 @@ function formatExecuteSliceDryRunReport({ provider, role, contextPack, slice, br
     `Prompt transport: ${invocation.promptTransport.mode}`,
     `Prompt length: ${invocation.promptLength} bytes`,
     `Commit after validation: ${commitEnabled ? 'enabled' : 'disabled'}`,
+  ];
+  if (invocation.modelSelection && invocation.modelSelection.model) {
+    lines.push(`Model: ${invocation.modelSelection.model}`);
+    lines.push(`Model support: ${invocation.modelSelection.supported ? 'supported' : 'unsupported'} (${invocation.modelSelection.reason})`);
+  }
+  lines.push(
     'Allowed files:',
     ...formatList(allowedFiles),
     'Validation commands:',
     ...formatList(validationCommands),
-  ];
+  );
 
   return `${lines.join('\n')}\n`;
 }
@@ -711,19 +928,21 @@ function writeExecutionArtifacts(repoRoot, executorContext, details) {
 async function runExecuteSlice(repoRoot, options = {}) {
   const canonicalRepoRoot = canonicalizeRepoRoot(repoRoot);
   const role = normalizeRole(options.role || DEFAULT_EXECUTE_ROLE);
-  const provider = options.providerExplicit === true || (options.provider && options.providerExplicit !== false)
-    ? String(options.provider || DEFAULT_EXECUTE_PROVIDER).trim().toLowerCase()
-    : resolveProfileProvider(canonicalRepoRoot, role, DEFAULT_EXECUTE_PROVIDER);
+  const selectedSlice = await resolveInteractiveSliceInput(canonicalRepoRoot, options);
+  const selectedExecutorProfile = await resolveInteractiveExecutorProfile(canonicalRepoRoot, role, options);
+  const resolvedOptions = {
+    ...options,
+    executorProfile: selectedExecutorProfile || options.executorProfile,
+    slice: selectedSlice,
+  };
+  const runtimeProfile = resolveExecutorRuntimeProfile(canonicalRepoRoot, role, resolvedOptions);
+  const provider = runtimeProfile.provider;
   const context = options.context || DEFAULT_EXECUTE_CONTEXT;
   const timeoutMs = normalizeTimeout(options.timeout);
 
-  if (!options.slice) {
-    throw new Error(formatError('missing required --slice path for ai execute-slice'));
-  }
-
   const executorContext = buildExecuteSliceContext({
     repoRoot: canonicalRepoRoot,
-    slicePath: options.slice,
+    slicePath: resolvedOptions.slice,
     role,
     context,
   });
@@ -736,6 +955,8 @@ async function runExecuteSlice(repoRoot, options = {}) {
       prompt,
       cwd: canonicalRepoRoot,
       timeoutMs,
+      model: runtimeProfile.model,
+      enforceModelSelection: false,
     });
   } catch (error) {
     throw annotateProviderError(error, 'execute-slice');
@@ -753,6 +974,7 @@ async function runExecuteSlice(repoRoot, options = {}) {
       allowedFiles: executorContext.allowedFiles,
       validationCommands: executorContext.validationCommands,
       commitEnabled: options.commit === true,
+      profile: runtimeProfile,
     };
     process.stdout.write(formatExecuteSliceDryRunReport({
       provider,
@@ -782,21 +1004,40 @@ async function runExecuteSlice(repoRoot, options = {}) {
     throw appendRecovery(new Error(formatError(`ai execute-slice requires a clean worktree before running. Commit or stash first: ${beforeSnapshot.files.join(', ')}`)), executorContext.slice);
   }
 
+  const ux = createCommandUx(options);
+  const showProgress = shouldShowHumanProgress(ux, options);
+  writeProgressChecks(
+    ux,
+    showProgress,
+    `Ejecutando slice con ${runtimeProfile.displayName}`,
+    ['Leyendo slice', 'Validando worktree', 'Preparando prompt'],
+  );
+
   let result;
   try {
-    result = await (options.runProviderFn || runProvider)(provider, {
-      prompt,
-      cwd: canonicalRepoRoot,
-      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: canonicalRepoRoot,
+        timeoutMs,
+        dryRun: false,
+        probe: options.probe,
+        spawn: options.spawn,
+        tempRoot: options.tempRoot,
+        tempFileName: options.tempFileName,
+        tempFilePrefix: options.tempFilePrefix,
+        model: runtimeProfile.model,
+        enforceModelSelection: Boolean(runtimeProfile.model),
+      }),
     });
   } catch (error) {
-    throw appendRecovery(annotateProviderError(error, 'execute-slice'), executorContext.slice);
+    if (error.providerResult) {
+      result = error.providerResult;
+    } else {
+      throw appendRecovery(annotateProviderError(error, 'execute-slice'), executorContext.slice);
+    }
   }
 
   if (result.stdout) {
@@ -840,11 +1081,18 @@ async function runExecuteSlice(repoRoot, options = {}) {
 
   let validationResults = [];
   try {
-    validationResults = runValidationCommands(
-      canonicalRepoRoot,
-      executorContext.validationCommands,
-      options.runValidationCommandFn,
-    );
+    validationResults = await runWithProgress({
+      ux,
+      enabled: showProgress && executorContext.validationCommands.length > 0,
+      message: 'Ejecutando validaciones...',
+      successMessage: 'Validaciones completadas',
+      failureMessage: 'Fallaron las validaciones',
+      run: () => runValidationCommands(
+        canonicalRepoRoot,
+        executorContext.validationCommands,
+        options.runValidationCommandFn,
+      ),
+    });
   } catch (error) {
     throw appendRecovery(error, executorContext.slice);
   }
@@ -872,8 +1120,15 @@ async function runExecuteSlice(repoRoot, options = {}) {
   let commitResult = null;
   if (options.commit === true) {
     try {
-      commitResult = commitSliceChanges(canonicalRepoRoot, executorContext.slice, finalScopeResult.changedFiles, {
-        message: options.commitMessage,
+      commitResult = await runWithProgress({
+        ux,
+        enabled: showProgress,
+        message: 'Creando commit del slice...',
+        successMessage: 'Commit del slice creado',
+        failureMessage: 'Fallo creando commit del slice',
+        run: () => commitSliceChanges(canonicalRepoRoot, executorContext.slice, finalScopeResult.changedFiles, {
+          message: options.commitMessage,
+        }),
       });
     } catch (error) {
       throw appendRecovery(error, executorContext.slice);
@@ -894,6 +1149,7 @@ async function runExecuteSlice(repoRoot, options = {}) {
     provider,
     role,
     contextPack: executorContext.context.packName,
+    profile: runtimeProfile,
     slice: executorContext.slice.sliceId,
     specSlug: executorContext.slice.specSlug,
     invocation,

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

@@ -11,6 +11,8 @@ const PROVIDERS = {
     id: 'codex',
     command: 'codex',
     args: ['exec'],
+    supportsModelSelection: true,
+    modelArgBuilder: (model) => ['--model', model],
     timeoutMs: 10 * 60 * 1000,
     installHint: 'Install the Codex CLI and make sure it is available on PATH.',
   },
@@ -18,6 +20,8 @@ const PROVIDERS = {
     id: 'claude',
     command: 'claude',
     args: ['-p'],
+    supportsModelSelection: true,
+    modelArgBuilder: (model) => ['--model', model],
     timeoutMs: 10 * 60 * 1000,
     installHint: 'Install the Claude CLI and make sure it is available on PATH.',
   },
@@ -25,6 +29,8 @@ const PROVIDERS = {
     id: 'gemini',
     command: 'gemini',
     args: ['--prompt', ''],
+    supportsModelSelection: true,
+    modelArgBuilder: (model) => ['--model', model],
     timeoutMs: 10 * 60 * 1000,
     installHint: 'Install the Gemini CLI and make sure it is available on PATH.',
   },
@@ -61,9 +67,68 @@ function getProviderDefinition(providerId) {
   return PROVIDERS[normalized];
 }
 
+function normalizeProviderModel(model) {
+  const value = String(model || '').trim();
+  return value || '';
+}
+
+function buildProviderModelArgs(providerId, model, options = {}) {
+  const provider = getProviderDefinition(providerId);
+  const normalizedModel = normalizeProviderModel(model);
+  const enforce = options.enforce === true;
+
+  if (!normalizedModel) {
+    return {
+      model: '',
+      supported: Boolean(provider.supportsModelSelection),
+      enforced: enforce,
+      args: [],
+      reason: 'no model selected',
+    };
+  }
+
+  if (provider.supportsModelSelection !== true || typeof provider.modelArgBuilder !== 'function') {
+    if (enforce) {
+      throw new ProviderRunnerError(
+        'UNSUPPORTED_PROVIDER_MODEL_SELECTION',
+        `Provider '${provider.id}' cannot receive model '${normalizedModel}' through its Quiver adapter. Remove the model selection or update the provider adapter before live execution.`,
+        {
+          provider: provider.id,
+          model: normalizedModel,
+          nextSteps: [
+            `Run without a model override for provider '${provider.id}'.`,
+            `Update the '${provider.id}' provider adapter with model argument support.`,
+            'Use --dry-run to inspect the invocation before live execution.',
+          ],
+        },
+      );
+    }
+
+    return {
+      model: normalizedModel,
+      supported: false,
+      enforced: false,
+      args: [],
+      reason: 'provider adapter does not support model arguments',
+    };
+  }
+
+  const args = provider.modelArgBuilder(normalizedModel);
+  return {
+    model: normalizedModel,
+    supported: true,
+    enforced: enforce,
+    args: Array.isArray(args) ? args.map((arg) => String(arg)) : [],
+    reason: 'model argument supported',
+  };
+}
+
 function buildProviderInvocation(providerId, options = {}) {
   const provider = getProviderDefinition(providerId);
   const extraArgs = Array.isArray(options.args) ? options.args.map((arg) => String(arg)) : [];
+  const modelSelection = buildProviderModelArgs(provider.id, options.model, {
+    enforce: options.enforceModelSelection === true,
+  });
   const prompt = String(options.prompt ?? '');
   const timeoutMs = Number.isFinite(options.timeoutMs) ? Number(options.timeoutMs) : provider.timeoutMs;
   const cwd = options.cwd ? String(options.cwd) : process.cwd();
@@ -72,10 +137,11 @@ function buildProviderInvocation(providerId, options = {}) {
   return {
     provider: provider.id,
     command: provider.command,
-    args: provider.args.concat(extraArgs),
+    args: provider.args.concat(modelSelection.args, extraArgs),
     cwd,
     timeoutMs,
     promptLength: Buffer.byteLength(prompt, 'utf8'),
+    modelSelection,
     promptTransport: {
       mode: transportMode,
       promptLength: Buffer.byteLength(prompt, 'utf8'),
@@ -93,6 +159,7 @@ function createDryRunResult(invocation) {
     args: invocation.args.slice(),
     cwd: invocation.cwd,
     timeoutMs: invocation.timeoutMs,
+    modelSelection: invocation.modelSelection,
     promptTransport: invocation.promptTransport,
     exitCode: 0,
     stdout: '',
@@ -256,6 +323,7 @@ async function runProvider(providerId, options = {}) {
       args: invocation.args.slice(),
       cwd: invocation.cwd,
       timeoutMs: invocation.timeoutMs,
+      modelSelection: invocation.modelSelection,
       promptTransport: invocation.promptTransport,
       exitCode: null,
       stdout: '',
@@ -292,6 +360,7 @@ async function runProvider(providerId, options = {}) {
       args: invocation.args.slice(),
       cwd: invocation.cwd,
       timeoutMs: invocation.timeoutMs,
+      modelSelection: invocation.modelSelection,
       promptTransport: describePromptTransport(transport),
       exitCode: execution.exitCode,
       signal: execution.signal,
@@ -309,6 +378,7 @@ module.exports = {
   SUPPORTED_PROVIDERS,
   ProviderRunnerError,
   assertSupportedProvider,
+  buildProviderModelArgs,
   buildProviderInvocation,
   formatProviderList,
   getProviderDefinition,

package/src/create-quiver/lib/cli/selectors.js

@@ -0,0 +1,107 @@
+const { resolveUxMode } = require('./ux');
+
+function formatError(message) {
+  return `create-quiver: ${message}`;
+}
+
+function normalizeSelectorOptions(options = []) {
+  return options.map((option) => {
+    if (typeof option === 'string') {
+      return {
+        label: option,
+        value: option,
+        hint: '',
+        default: false,
+      };
+    }
+    return {
+      label: String(option.label || option.name || option.id || option.value || ''),
+      value: String(option.value || option.id || option.path || option.label || ''),
+      hint: option.hint || option.description || '',
+      default: option.default === true || option.recommended === true,
+      raw: option.raw || option,
+    };
+  }).filter((option) => option.label && option.value);
+}
+
+function findOption(options, value) {
+  const normalized = String(value || '').trim();
+  if (!normalized) return null;
+  return options.find((option) => option.value === normalized || option.label === normalized) || null;
+}
+
+function resolveDefaultOption(options, defaultValue) {
+  return findOption(options, defaultValue) || options.find((option) => option.default) || (options.length === 1 ? options[0] : null);
+}
+
+async function loadClack(injected) {
+  if (injected) return injected;
+  return import('@clack/prompts');
+}
+
+async function selectOption(message, rawOptions, options = {}) {
+  const normalizedOptions = normalizeSelectorOptions(rawOptions);
+  if (normalizedOptions.length === 0) {
+    throw new Error(formatError(`${options.name || 'selection'} has no available options.`));
+  }
+
+  const explicit = findOption(normalizedOptions, options.value);
+  if (explicit) return explicit;
+  if (options.value) {
+    throw new Error(formatError(`${options.name || 'selection'} option '${options.value}' was not found.`));
+  }
+
+  const mode = resolveUxMode({
+    interactive: options.interactive === true,
+    json: options.json,
+    noColor: options.noColor,
+    stdinIsTTY: options.stdinIsTTY,
+    stdoutIsTTY: options.stdoutIsTTY,
+    stderrIsTTY: options.stderrIsTTY,
+  }, options.env || process.env, {
+    input: options.input || process.stdin,
+    output: options.output || process.stdout,
+    error: options.error || process.stderr,
+  });
+
+  if (mode.usePrompts) {
+    if (typeof options.promptSelect === 'function') {
+      const selected = await options.promptSelect(message, normalizedOptions);
+      const match = findOption(normalizedOptions, selected);
+      if (!match) {
+        throw new Error(formatError(`${options.name || 'selection'} prompt returned unknown option '${selected}'.`));
+      }
+      return match;
+    }
+    const clack = await loadClack(options.prompts);
+    const selected = await clack.select({
+      message,
+      options: normalizedOptions.map((option) => ({
+        label: option.label,
+        value: option.value,
+        hint: option.hint || undefined,
+      })),
+      initialValue: resolveDefaultOption(normalizedOptions, options.defaultValue)?.value,
+    });
+    if (clack.isCancel && clack.isCancel(selected)) {
+      throw new Error(formatError(`${options.name || 'selection'} was canceled.`));
+    }
+    return findOption(normalizedOptions, selected);
+  }
+
+  const fallback = resolveDefaultOption(normalizedOptions, options.defaultValue);
+  if (fallback) return fallback;
+
+  const flag = options.flag || '--value';
+  const available = normalizedOptions.map((option) => option.value).join(', ');
+  throw new Error(formatError([
+    `${options.name || 'selection'} requires an explicit choice.`,
+    `Available options: ${available}.`,
+    `Use ${flag} <value> or rerun with --interactive.`,
+  ].join('\n')));
+}
+
+module.exports = {
+  normalizeSelectorOptions,
+  selectOption,
+};

package/src/create-quiver/lib/cli/theme.js

@@ -9,8 +9,11 @@ const QUIVER_COLORS = Object.freeze({
 const STATUS_COLORS = Object.freeze({
   info: 'sky',
   command: 'blue',
+  success: 'blue',
   planner: 'violet',
   review: 'magenta',
+  warning: 'magenta',
+  error: 'magenta',
   risk: 'magenta',
   muted: 'periwinkle',
 });
@@ -70,8 +73,8 @@ function resolveTheme(options = {}, env = process.env, tty = {}) {
   const useColor = shouldUseColor(options, env, tty);
   const useUnicode = shouldUseUnicode(options, env, tty);
   const symbols = useUnicode
-    ? { start: '◇', success: '✓', warning: '!', error: '✖', bullet: '•' }
-    : { start: '*', success: 'OK', warning: 'WARN', error: 'ERR', bullet: '-' };
+    ? { start: '◇', section: '◆', success: '✓', warning: '!', error: '✖', bullet: '•' }
+    : { start: '*', section: '*', success: 'OK', warning: 'WARN', error: 'ERR', bullet: '-' };
   const theme = {
     colors: QUIVER_COLORS,
     statusColors: STATUS_COLORS,

package/src/create-quiver/lib/cli/ux-flags.js

@@ -5,6 +5,12 @@ const UX_FLAG_OPTIONS = Object.freeze({
 });
 
 const UX_FLAG_MATRIX = Object.freeze({
+  init: Object.freeze({
+    withPlanner: false,
+    interactive: true,
+    review: false,
+    note: 'guided project onboarding choices',
+  }),
   'ai prepare-context': Object.freeze({
     withPlanner: true,
     interactive: true,
@@ -29,6 +35,18 @@ const UX_FLAG_MATRIX = Object.freeze({
     review: true,
     note: 'PR body review and interactive PR inputs',
   }),
+  'ai execute-slice': Object.freeze({
+    withPlanner: false,
+    interactive: true,
+    review: false,
+    note: 'executor profile and ready-slice selection',
+  }),
+  'ai execute-plan': Object.freeze({
+    withPlanner: false,
+    interactive: true,
+    review: false,
+    note: 'execution strategy confirmation and future selectors',
+  }),
 });
 
 function formatError(message) {