@poetic-ai/poetic 1.42.0

package/dist/chunk-4BOP7T6L.js

@@ -0,0 +1,2321 @@
+import {
+  AutomaticPromptOptimizer,
+  PromptEvaluator,
+  PromptOptimizer
+} from "./chunk-7MMLMXO6.js";
+import {
+  PromptManager
+} from "./chunk-Q3WIC6GQ.js";
+import {
+  PromptStore
+} from "./chunk-OQ6K46CK.js";
+import {
+  registry
+} from "./chunk-Z2KYOFHS.js";
+import {
+  BUILT_IN_VARIANT_STRATEGIES
+} from "./chunk-VXF4Q3FW.js";
+import {
+  getTelemetryLogger
+} from "./chunk-U6C3VVWS.js";
+import {
+  GEMINI_MODELS
+} from "./chunk-V53UG2OT.js";
+import {
+  resolveDefaultProvider
+} from "./chunk-XPU2XADL.js";
+import {
+  CODEX_MODELS
+} from "./chunk-4NXPXE62.js";
+import {
+  CLAUDE_MODELS
+} from "./chunk-MWHLBPNU.js";
+import {
+  BooleanFlagSchema,
+  ExistingFilePathSchema,
+  PromptCategorySchema,
+  PromptContentSchema,
+  PromptIdSchema,
+  PromptNameSchema,
+  validateCommandOptions
+} from "./chunk-QOCOVLUH.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+
+// src/cli/commands/prompts.ts
+import * as fs from "fs";
+import chalk from "chalk";
+import { Command } from "commander";
+import { z } from "zod";
+
+// src/core/providers/copilot/config.ts
+var COPILOT_MODELS = {
+  // Current models
+  CLAUDE_SONNET_4_6: "claude-sonnet-4.6",
+  CLAUDE_SONNET_4_5: "claude-sonnet-4.5",
+  CLAUDE_SONNET_4: "claude-sonnet-4",
+  CLAUDE_HAIKU_4_5: "claude-haiku-4.5",
+  CLAUDE_OPUS_4_6: "claude-opus-4.6",
+  CLAUDE_OPUS_4_5: "claude-opus-4.5",
+  CLAUDE_OPUS_4_1: "claude-opus-4.1",
+  GPT_5: "gpt-5",
+  GPT_5_MINI: "gpt-5-mini",
+  GPT_5_1_CODEX_MINI: "gpt-5.1-codex-mini",
+  GPT_5_2: "gpt-5.2",
+  GEMINI_2_5_PRO: "gemini-2.5-pro",
+  GEMINI_3_FLASH: "gemini-3-flash",
+  GEMINI_3_PRO: "gemini-3-pro",
+  // Legacy models
+  GPT_4_1: "gpt-4.1"
+};
+var DEFAULT_TIMEOUT = ProviderRegistry.getTimeout("copilot");
+
+// src/orchestrator/model-tier-config.ts
+var TIER_PREFERENCE_AVAILABILITY_KEYS = ["anthropic", "openai", "google", "opencode"];
+function resolveTierPreferenceOrder() {
+  const eligible = new Set(TIER_PREFERENCE_AVAILABILITY_KEYS);
+  try {
+    const ordered = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const provider of ProviderRegistry.getEnabledProviders()) {
+      const availabilityKey = normalizeProviderForModelAvailability(provider.id);
+      if (!eligible.has(availabilityKey) || seen.has(availabilityKey)) continue;
+      seen.add(availabilityKey);
+      ordered.push(availabilityKey);
+    }
+    for (const key of TIER_PREFERENCE_AVAILABILITY_KEYS) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        ordered.push(key);
+      }
+    }
+    return ordered;
+  } catch {
+    return [...TIER_PREFERENCE_AVAILABILITY_KEYS];
+  }
+}
+var MODEL_AVAILABILITY_PROVIDER_BY_ALIAS = {
+  anthropic: "anthropic",
+  claude: "anthropic",
+  openai: "openai",
+  codex: "openai",
+  google: "google",
+  gemini: "google",
+  opencode: "opencode"
+};
+var REGISTRY_PROVIDER_BY_MODEL_AVAILABILITY_PROVIDER = {
+  anthropic: "claude",
+  openai: "codex",
+  google: "gemini",
+  cursor: "cursor",
+  copilot: "copilot",
+  opencode: "opencode"
+};
+var FALLBACK_PROVIDER_BY_ALIAS = {
+  anthropic: "claude",
+  claude: "claude",
+  openai: "codex",
+  codex: "codex",
+  google: "gemini",
+  gemini: "gemini"
+};
+var STATIC_MODEL_AVAILABILITY_FALLBACK = {
+  basicModels: {
+    openai: [CODEX_MODELS.GPT_5_4_MINI],
+    codex: [CODEX_MODELS.GPT_5_4_MINI],
+    anthropic: [CLAUDE_MODELS.CLAUDE_HAIKU_4_5],
+    claude: [CLAUDE_MODELS.CLAUDE_HAIKU_4_5],
+    google: [GEMINI_MODELS.FLASH_2_5_LITE],
+    gemini: [GEMINI_MODELS.FLASH_2_5_LITE],
+    cursor: ["auto"],
+    copilot: [COPILOT_MODELS.GPT_5_MINI],
+    opencode: ["auto"]
+  },
+  standardModels: {
+    openai: [CODEX_MODELS.GPT_5_5],
+    codex: [CODEX_MODELS.GPT_5_5],
+    anthropic: [CLAUDE_MODELS.CLAUDE_SONNET_4_6],
+    claude: [CLAUDE_MODELS.CLAUDE_SONNET_4_6],
+    google: [GEMINI_MODELS.FLASH_2_5],
+    gemini: [GEMINI_MODELS.FLASH_2_5],
+    cursor: ["auto"],
+    copilot: [COPILOT_MODELS.GPT_5_MINI],
+    opencode: ["auto"]
+  },
+  advancedModels: {
+    openai: [CODEX_MODELS.GPT_5_5],
+    codex: [CODEX_MODELS.GPT_5_5],
+    anthropic: [CLAUDE_MODELS.CLAUDE_OPUS_4_6],
+    claude: [CLAUDE_MODELS.CLAUDE_OPUS_4_6],
+    google: [GEMINI_MODELS.PRO_3_PREVIEW],
+    gemini: [GEMINI_MODELS.PRO_3_PREVIEW],
+    cursor: ["auto"],
+    copilot: [COPILOT_MODELS.GPT_5_MINI],
+    opencode: ["auto"]
+  }
+};
+var ROLE_PRIORITY_BY_TIER = {
+  basic: ["fast", "default"],
+  standard: ["default"],
+  advanced: ["quality", "reasoning", "default"]
+};
+function normalizeProviderForModelAvailability(provider) {
+  const normalized = (provider || "").toLowerCase().trim();
+  if (!normalized) return normalized;
+  return MODEL_AVAILABILITY_PROVIDER_BY_ALIAS[normalized] ?? normalized;
+}
+function getRegistryProviderForModelAvailability(provider) {
+  const normalized = normalizeProviderForModelAvailability(provider);
+  return REGISTRY_PROVIDER_BY_MODEL_AVAILABILITY_PROVIDER[normalized];
+}
+function cloneModelAvailability(availability) {
+  return {
+    basicModels: Object.fromEntries(
+      Object.entries(availability.basicModels).map(([provider, models]) => [provider, [...models]])
+    ),
+    standardModels: Object.fromEntries(
+      Object.entries(availability.standardModels).map(([provider, models]) => [
+        provider,
+        [...models]
+      ])
+    ),
+    advancedModels: Object.fromEntries(
+      Object.entries(availability.advancedModels).map(([provider, models]) => [
+        provider,
+        [...models]
+      ])
+    )
+  };
+}
+function uniqueModels(models) {
+  return Array.from(new Set(models.filter((model) => Boolean(model?.trim()))));
+}
+function resolveRegistryModel(providerId, role) {
+  try {
+    if (role === "default") {
+      return ProviderRegistry.getDefaultModel(providerId);
+    }
+    return ProviderRegistry.getModelForRole(providerId, role);
+  } catch (_error) {
+    return void 0;
+  }
+}
+function buildRegistryBackedAvailability() {
+  const availability = cloneModelAvailability(STATIC_MODEL_AVAILABILITY_FALLBACK);
+  const providerKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(STATIC_MODEL_AVAILABILITY_FALLBACK.basicModels),
+    ...Object.keys(STATIC_MODEL_AVAILABILITY_FALLBACK.standardModels),
+    ...Object.keys(STATIC_MODEL_AVAILABILITY_FALLBACK.advancedModels)
+  ]);
+  for (const availabilityProvider of providerKeys) {
+    const registryProvider = getRegistryProviderForModelAvailability(availabilityProvider);
+    if (!registryProvider) continue;
+    for (const tier of ["basic", "standard", "advanced"]) {
+      const roles = ROLE_PRIORITY_BY_TIER[tier];
+      let resolved;
+      for (const role of roles) {
+        resolved = resolveRegistryModel(registryProvider, role);
+        if (resolved) break;
+      }
+      if (!resolved) continue;
+      getAvailabilityForTier(tier, availability)[availabilityProvider] = [resolved];
+    }
+  }
+  return availability;
+}
+var DEFAULT_MODEL_AVAILABILITY = buildRegistryBackedAvailability();
+function getAvailabilityForTier(tier, availability = DEFAULT_MODEL_AVAILABILITY) {
+  if (tier === "basic") return availability.basicModels;
+  if (tier === "standard") return availability.standardModels;
+  return availability.advancedModels;
+}
+function hasRawModelAvailabilityForProvider(provider, availability = DEFAULT_MODEL_AVAILABILITY) {
+  const providerKey = normalizeProviderForModelAvailability(provider);
+  return (availability.basicModels[providerKey]?.length ?? 0) > 0 || (availability.standardModels[providerKey]?.length ?? 0) > 0 || (availability.advancedModels[providerKey]?.length ?? 0) > 0;
+}
+function getProvidersWithRouteModelAvailability(availability = DEFAULT_MODEL_AVAILABILITY) {
+  const providers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addIfRoutable = (providerId) => {
+    if (!hasRawModelAvailabilityForProvider(providerId, availability)) return;
+    const providerKey = normalizeProviderForModelAvailability(providerId);
+    const userFacingProvider = getRegistryProviderForModelAvailability(providerKey) ?? providerKey;
+    if (seen.has(userFacingProvider)) return;
+    seen.add(userFacingProvider);
+    providers.push(userFacingProvider);
+  };
+  try {
+    for (const provider of ProviderRegistry.getEnabledProviders()) {
+      addIfRoutable(provider.id);
+    }
+  } catch {
+    for (const providerId of /* @__PURE__ */ new Set([
+      ...Object.keys(availability.basicModels),
+      ...Object.keys(availability.standardModels),
+      ...Object.keys(availability.advancedModels)
+    ])) {
+      addIfRoutable(providerId);
+    }
+  }
+  return providers;
+}
+function hasProviderRouteModelAvailability(provider, availability = DEFAULT_MODEL_AVAILABILITY) {
+  return getProvidersWithRouteModelAvailability(availability).includes(
+    getRegistryProviderForModelAvailability(normalizeProviderForModelAvailability(provider)) ?? normalizeProviderForModelAvailability(provider)
+  );
+}
+function buildTierPreference(tier) {
+  const availability = getAvailabilityForTier(tier);
+  const entries = [];
+  for (const provider of resolveTierPreferenceOrder()) {
+    const models = availability[provider] || [];
+    entries.push(...models);
+  }
+  return uniqueModels(entries);
+}
+var TIER_MODEL_PREFERENCE = {
+  basic: buildTierPreference("basic"),
+  standard: buildTierPreference("standard"),
+  advanced: buildTierPreference("advanced")
+};
+function getModelsForTierByProvider(tier, provider) {
+  const availability = getAvailabilityForTier(tier);
+  const providerKey = normalizeProviderForModelAvailability(provider);
+  const scoped = availability[providerKey] || [];
+  if (scoped.length > 0) {
+    return [...scoped];
+  }
+  return [];
+}
+var MERGED_PROVIDER_MODEL_FALLBACK = {
+  claude: {
+    fast: CLAUDE_MODELS.CLAUDE_HAIKU_4_5,
+    default: CLAUDE_MODELS.CLAUDE_SONNET_4_6,
+    advanced: CLAUDE_MODELS.CLAUDE_OPUS_4_6
+  },
+  codex: {
+    fast: CODEX_MODELS.GPT_5_4_MINI,
+    default: CODEX_MODELS.GPT_5_5,
+    advanced: CODEX_MODELS.GPT_5_5
+  },
+  gemini: {
+    fast: GEMINI_MODELS.FLASH_2_5_LITE,
+    default: GEMINI_MODELS.FLASH_2_5,
+    advanced: GEMINI_MODELS.PRO_3_PREVIEW
+  },
+  cursor: {
+    // Cursor's model should come from repo config (typically `auto`).
+  },
+  copilot: {
+    // Dot notation required by the GitHub Copilot CLI — do not normalize.
+    fast: COPILOT_MODELS.GPT_5_MINI,
+    default: COPILOT_MODELS.CLAUDE_SONNET_4_6,
+    advanced: COPILOT_MODELS.CLAUDE_OPUS_4_6
+  },
+  opencode: {
+    fast: "auto",
+    default: "auto",
+    advanced: "auto"
+  }
+};
+function getModelFromFallback(provider, tier) {
+  const normalized = (provider || "").toLowerCase().trim();
+  const fallbackProvider = FALLBACK_PROVIDER_BY_ALIAS[normalized] ?? normalized;
+  return MERGED_PROVIDER_MODEL_FALLBACK[fallbackProvider]?.[tier];
+}
+
+// src/prompts/generator.ts
+function resolveDefaultGeneratorProvider() {
+  try {
+    return resolveDefaultProvider().value;
+  } catch {
+    return "";
+  }
+}
+var DEFAULT_PROMPT_GENERATOR_MODEL = (() => {
+  const defaultProvider = resolveDefaultGeneratorProvider();
+  if (!defaultProvider) {
+    return "";
+  }
+  return ProviderRegistry.getDefaultModel(defaultProvider) ?? getModelFromFallback(defaultProvider, "default") ?? "";
+})();
+var BUILT_IN_TEMPLATES = {
+  "strategy-conservative": {
+    id: "strategy-conservative",
+    name: "Conservative Strategy Template",
+    description: "Template for conservative approach prompts",
+    category: "strategy",
+    template: `CONSERVATIVE APPROACH
+{{goal}}
+
+You are a coding agent (conservative style).
+
+FILE TARGETS:
+{{context}}
+
+Guidance:
+- Follow existing patterns in the codebase.
+- Keep changes small, focused, and backwards-compatible.
+- Write defensive code with error handling at boundaries.
+- Avoid unrelated refactors.
+- Write the code now; no plan-only output.
+
+{{constraints}}
+
+Requirements:
+{{requirements}}
+
+Expected Outcomes:
+{{outcomes}}
+
+FILE TARGET RULES:
+- (create) = permission to create; do not ask
+- (modify) = must exist; do not create; if missing, find correct file and note substitution; ask only if blocked
+- No marker = treat as (modify) if exists, else ask
+
+Edit the listed files. Done.`,
+    placeholders: [
+      {
+        key: "goal",
+        description: "The main goal or task description",
+        required: true
+      },
+      {
+        key: "context",
+        description: "Additional context about the task",
+        required: false,
+        defaultValue: ""
+      },
+      {
+        key: "constraints",
+        description: "Any constraints or limitations",
+        required: false,
+        defaultValue: ""
+      },
+      {
+        key: "requirements",
+        description: "Specific requirements (bullet points)",
+        required: true
+      },
+      {
+        key: "outcomes",
+        description: "Expected outcomes or deliverables",
+        required: true
+      }
+    ]
+  },
+  "strategy-innovative": {
+    id: "strategy-innovative",
+    name: "Innovative Strategy Template",
+    description: "Template for innovative approach prompts",
+    category: "strategy",
+    template: `INNOVATIVE APPROACH
+{{goal}}
+
+You are a coding agent (innovative style).
+
+FILE TARGETS:
+{{context}}
+
+Guidance:
+- Explore modern patterns that improve performance, UX, or developer experience.
+- Be bold and creative; implement novel solutions directly.
+- Prioritize code elegance and efficiency over strict convention.
+- Keep changes coherent and testable; avoid gratuitous complexity.
+- Write the code now; no plan-only output.
+
+{{constraints}}
+
+Requirements:
+{{requirements}}
+
+Expected Outcomes:
+{{outcomes}}
+
+FILE TARGET RULES:
+- (create) = permission to create; do not ask
+- (modify) = must exist; do not create; if missing, find correct file and note substitution; ask only if blocked
+- No marker = treat as (modify) if exists, else ask
+
+Edit the listed files. Done.`,
+    placeholders: [
+      {
+        key: "goal",
+        description: "The main goal or task description",
+        required: true
+      },
+      {
+        key: "context",
+        description: "Additional context about the task",
+        required: false,
+        defaultValue: ""
+      },
+      {
+        key: "constraints",
+        description: "Any constraints or limitations",
+        required: false,
+        defaultValue: ""
+      },
+      {
+        key: "requirements",
+        description: "Specific requirements (bullet points)",
+        required: true
+      },
+      {
+        key: "outcomes",
+        description: "Expected outcomes or deliverables",
+        required: true
+      }
+    ]
+  },
+  "strategy-hybrid": {
+    id: "strategy-hybrid",
+    name: "Hybrid Strategy Template",
+    description: "Template for hybrid approach prompts",
+    category: "strategy",
+    template: `HYBRID APPROACH
+{{goal}}
+
+You are a coding agent (hybrid style).
+
+FILE TARGETS:
+{{context}}
+
+Guidance:
+- Blend proven patterns with targeted innovations where they clearly reduce risk.
+- Stabilize existing behavior first; add safety nets at modified surfaces.
+- Apply modern patterns only where they clearly reduce risk or complexity.
+- Preserve backwards compatibility unless explicitly allowed to break it.
+- Keep diffs tight and focused; avoid unrelated refactors.
+- Write the code now; no plan-only output.
+
+{{constraints}}
+
+Requirements:
+{{requirements}}
+
+Expected Outcomes:
+{{outcomes}}
+
+FILE TARGET RULES:
+- (create) = permission to create; do not ask
+- (modify) = must exist; do not create; if missing, find correct file and note substitution; ask only if blocked
+- No marker = treat as (modify) if exists, else ask
+
+Edit the listed files. Done.`,
+    placeholders: [
+      {
+        key: "goal",
+        description: "The main goal or task description",
+        required: true
+      },
+      {
+        key: "context",
+        description: "Additional context about the task",
+        required: false,
+        defaultValue: ""
+      },
+      {
+        key: "constraints",
+        description: "Any constraints or limitations",
+        required: false,
+        defaultValue: ""
+      },
+      {
+        key: "requirements",
+        description: "Specific requirements (bullet points)",
+        required: true
+      },
+      {
+        key: "outcomes",
+        description: "Expected outcomes or deliverables",
+        required: true
+      }
+    ]
+  },
+  "domain-feature": {
+    id: "domain-feature",
+    name: "Feature Implementation Template",
+    description: "Template for implementing new features",
+    category: "domain",
+    template: `Implement {{feature_name}} feature for {{project_context}}.
+
+Description:
+{{description}}
+
+Technical Requirements:
+{{tech_requirements}}
+
+Acceptance Criteria:
+{{acceptance_criteria}}
+
+Implementation Notes:
+- Follow existing patterns in {{codebase_pattern}}
+- Ensure backwards compatibility
+- Add comprehensive tests (unit + integration)
+- Update documentation
+- Consider edge cases and error handling
+
+{{additional_notes}}`,
+    placeholders: [
+      {
+        key: "feature_name",
+        description: "Name of the feature",
+        required: true
+      },
+      {
+        key: "project_context",
+        description: "Project or module context",
+        required: true
+      },
+      {
+        key: "description",
+        description: "Detailed feature description",
+        required: true
+      },
+      {
+        key: "tech_requirements",
+        description: "Technical requirements",
+        required: true
+      },
+      {
+        key: "acceptance_criteria",
+        description: "Acceptance criteria",
+        required: true
+      },
+      {
+        key: "codebase_pattern",
+        description: "Existing codebase pattern to follow",
+        required: false,
+        defaultValue: "the existing codebase"
+      },
+      {
+        key: "additional_notes",
+        description: "Any additional notes or considerations",
+        required: false,
+        defaultValue: ""
+      }
+    ]
+  },
+  "workflow-refactor": {
+    id: "workflow-refactor",
+    name: "Refactoring Template",
+    description: "Template for code refactoring tasks",
+    category: "workflow",
+    template: `Refactor {{target}} in {{module}}.
+
+Current State:
+{{current_state}}
+
+Issues:
+{{issues}}
+
+Desired State:
+{{desired_state}}
+
+Refactoring Strategy:
+- Identify and extract common patterns
+- Improve code organization and readability
+- Reduce duplication and complexity
+- Maintain existing functionality (no behavior changes)
+- Ensure all tests pass after refactoring
+- Update documentation if needed
+
+Constraints:
+{{constraints}}
+
+Success Criteria:
+{{success_criteria}}`,
+    placeholders: [
+      {
+        key: "target",
+        description: "What to refactor (function, class, module)",
+        required: true
+      },
+      {
+        key: "module",
+        description: "Module or file location",
+        required: true
+      },
+      {
+        key: "current_state",
+        description: "Description of current state",
+        required: true
+      },
+      {
+        key: "issues",
+        description: "Problems or issues to address",
+        required: true
+      },
+      {
+        key: "desired_state",
+        description: "Desired outcome after refactoring",
+        required: true
+      },
+      {
+        key: "constraints",
+        description: "Any constraints (e.g., no API changes)",
+        required: false,
+        defaultValue: "No breaking changes to public APIs"
+      },
+      {
+        key: "success_criteria",
+        description: "How to measure success",
+        required: false,
+        defaultValue: "All tests pass, code is more maintainable"
+      }
+    ]
+  }
+};
+var PromptGenerator = class {
+  store;
+  manager;
+  templates;
+  engine;
+  defaultModel;
+  profile;
+  workingDir;
+  constructor(options = {}) {
+    this.store = new PromptStore(options);
+    this.manager = new PromptManager(options);
+    this.templates = /* @__PURE__ */ new Map();
+    this.engine = options.engine;
+    this.defaultModel = options.defaultModel || DEFAULT_PROMPT_GENERATOR_MODEL;
+    this.profile = options.profile || "default";
+    this.workingDir = options.workingDir || process.cwd();
+    Object.entries(BUILT_IN_TEMPLATES).forEach(([id, template]) => {
+      this.templates.set(id, template);
+    });
+  }
+  /**
+   * Generate a prompt from a request using AI engine or templates
+   */
+  async generate(request) {
+    try {
+      if (this.engine) {
+        return await this.generateWithAI(request);
+      }
+      return await this.generateFromTemplates(request);
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        model: this.engine ? request.model || this.defaultModel : "template-based",
+        duration: 0,
+        confidence: 0,
+        suggestedReview: []
+      };
+    }
+  }
+  /**
+   * Generate using AI engine
+   */
+  async generateWithAI(request) {
+    if (!this.engine) {
+      return {
+        success: false,
+        error: "No AI engine configured",
+        model: "none",
+        duration: 0,
+        confidence: 0,
+        suggestedReview: []
+      };
+    }
+    const startTime = Date.now();
+    const model = request.model || this.defaultModel;
+    try {
+      const generationPrompt = this.buildGenerationPrompt(request);
+      const result = await this.engine.run({
+        profile: this.profile,
+        prompt: generationPrompt,
+        workingDir: this.workingDir,
+        model,
+        // Prompt generation only parses stdout. engine.run is called directly
+        // here, so it does not inherit runProviderNative's read-only derivation.
+        executionIntent: "analysis",
+        readOnlyWorkingDir: true
+      });
+      if (result.exitCode !== 0) {
+        return {
+          success: false,
+          error: "AI generation failed",
+          model,
+          duration: Date.now() - startTime,
+          confidence: 0,
+          suggestedReview: []
+        };
+      }
+      const content = this.parseGeneratedContent(result.stdout);
+      if (!content || content.trim().length === 0) {
+        return {
+          success: false,
+          error: "Failed to parse generated content",
+          model,
+          duration: Date.now() - startTime,
+          confidence: 0,
+          suggestedReview: []
+        };
+      }
+      const confidence = this.calculateAIConfidence(content);
+      const suggestedReview = this.generateReviewChecklist(request, content);
+      const promptId = this.createPromptId(request.name);
+      return {
+        success: true,
+        prompt: {
+          id: promptId,
+          name: request.name,
+          description: request.description,
+          category: request.category,
+          status: "active",
+          variant: request.variant,
+          tags: request.tags || [],
+          autoOptimize: request.autoOptimize ?? false,
+          currentVersion: "v1.0.0",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          usageCount: 0
+        },
+        version: {
+          id: "v1.0.0",
+          promptId,
+          content,
+          contentHash: "",
+          isActive: true,
+          isGenerated: true,
+          generationModel: model,
+          generationPrompt,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        model,
+        duration: Date.now() - startTime,
+        confidence,
+        suggestedReview
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        model,
+        duration: Date.now() - startTime,
+        confidence: 0,
+        suggestedReview: []
+      };
+    }
+  }
+  /**
+   * Generate using templates (fallback)
+   */
+  async generateFromTemplates(request) {
+    try {
+      const template = this.selectTemplate(request);
+      if (!template) {
+        return {
+          success: false,
+          error: "No suitable template found for request",
+          model: "template-based",
+          duration: 0,
+          confidence: 0,
+          suggestedReview: []
+        };
+      }
+      const startTime = Date.now();
+      const content = this.buildFromTemplate(template, request);
+      const confidence = this.calculateTemplateConfidence(template, request);
+      const suggestedReview = this.generateReviewChecklist(request, content);
+      const promptId = this.createPromptId(request.name);
+      const duration = Date.now() - startTime;
+      return {
+        success: true,
+        prompt: {
+          id: promptId,
+          name: request.name,
+          description: request.description,
+          category: request.category,
+          status: "active",
+          variant: request.variant,
+          tags: request.tags || [],
+          autoOptimize: request.autoOptimize ?? false,
+          currentVersion: "v1.0.0",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          usageCount: 0
+        },
+        version: {
+          id: "v1.0.0",
+          promptId,
+          content,
+          contentHash: "",
+          isActive: true,
+          isGenerated: true,
+          generationModel: "template-based",
+          generationPrompt: JSON.stringify(request),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        model: "template-based",
+        duration,
+        confidence,
+        suggestedReview
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        model: "template-based",
+        duration: 0,
+        confidence: 0,
+        suggestedReview: []
+      };
+    }
+  }
+  /**
+   * Generate prompt from a template with provided values
+   */
+  generateFromTemplate(templateId, values) {
+    const template = this.templates.get(templateId);
+    if (!template) {
+      throw new Error(`Template "${templateId}" not found`);
+    }
+    return this.buildFromTemplate(template, values);
+  }
+  /**
+   * Get all available templates
+   */
+  getTemplates(category) {
+    const templates = Array.from(this.templates.values());
+    if (category) {
+      return templates.filter((t) => t.category === category);
+    }
+    return templates;
+  }
+  /**
+   * Get a specific template
+   */
+  getTemplate(id) {
+    return this.templates.get(id) || null;
+  }
+  /**
+   * Register a custom template
+   */
+  registerTemplate(template) {
+    this.templates.set(template.id, template);
+  }
+  /**
+   * Generate multiple variants with different strategies
+   */
+  async generateVariants(baseRequest, strategies) {
+    const results = [];
+    for (const strategy of strategies) {
+      const variantRequest = {
+        ...baseRequest,
+        name: `${baseRequest.name} (${strategy})`,
+        variant: strategy,
+        goal: `${baseRequest.goal} (${strategy} approach)`
+      };
+      const result = await this.generate(variantRequest);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Refine an existing prompt with improvements
+   */
+  async refine(promptId, refinementGoals) {
+    try {
+      const existingPrompt = this.manager.get(promptId);
+      if (!existingPrompt) {
+        return {
+          success: false,
+          error: `Prompt "${promptId}" not found`,
+          model: this.defaultModel,
+          duration: 0,
+          confidence: 0,
+          suggestedReview: []
+        };
+      }
+      const currentVersion = this.manager.getVersion(promptId, existingPrompt.currentVersion);
+      if (!currentVersion) {
+        return {
+          success: false,
+          error: `Current version not found for prompt "${promptId}"`,
+          model: this.defaultModel,
+          duration: 0,
+          confidence: 0,
+          suggestedReview: []
+        };
+      }
+      if (!this.engine) {
+        return {
+          success: false,
+          error: "No AI engine configured for refinement",
+          model: "none",
+          duration: 0,
+          confidence: 0,
+          suggestedReview: []
+        };
+      }
+      const startTime = Date.now();
+      const refinementPrompt = `You are an expert prompt engineer. Refine the following prompt based on these goals:
+
+Current Prompt:
+${currentVersion.content}
+
+Refinement Goals:
+${refinementGoals.map((goal, i) => `${i + 1}. ${goal}`).join("\n")}
+
+Generate an improved version of the prompt that addresses these refinement goals while maintaining its core purpose.
+
+Output the refined prompt after the marker "GENERATED PROMPT:" on a new line.`;
+      const result = await this.engine.run({
+        profile: this.profile,
+        prompt: refinementPrompt,
+        workingDir: this.workingDir,
+        model: this.defaultModel,
+        // Refinement only parses stdout; same direct-engine.run caveat as above.
+        executionIntent: "analysis",
+        readOnlyWorkingDir: true
+      });
+      if (result.exitCode !== 0) {
+        return {
+          success: false,
+          error: "Refinement generation failed",
+          model: this.defaultModel,
+          duration: Date.now() - startTime,
+          confidence: 0,
+          suggestedReview: []
+        };
+      }
+      const content = this.parseGeneratedContent(result.stdout);
+      if (!content || content.trim().length === 0) {
+        return {
+          success: false,
+          error: "Failed to parse refined content",
+          model: this.defaultModel,
+          duration: Date.now() - startTime,
+          confidence: 0,
+          suggestedReview: []
+        };
+      }
+      const confidence = this.calculateAIConfidence(content);
+      const versionId = `v${Date.now()}`;
+      await this.manager.createVersion({
+        promptId,
+        content,
+        version: versionId,
+        changelog: `Refined: ${refinementGoals.join(", ")}`,
+        isGenerated: true,
+        generationModel: this.defaultModel,
+        generationPrompt: refinementPrompt
+      });
+      return {
+        success: true,
+        prompt: existingPrompt,
+        version: {
+          id: versionId,
+          promptId,
+          content,
+          contentHash: "",
+          isActive: true,
+          isGenerated: true,
+          generationModel: this.defaultModel,
+          generationPrompt: refinementPrompt,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        model: this.defaultModel,
+        duration: Date.now() - startTime,
+        confidence,
+        suggestedReview: this.generateReviewChecklist(
+          {
+            name: existingPrompt.name,
+            description: existingPrompt.description,
+            category: existingPrompt.category,
+            goal: refinementGoals.join(", ")
+          },
+          content
+        )
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        model: this.defaultModel,
+        duration: 0,
+        confidence: 0,
+        suggestedReview: []
+      };
+    }
+  }
+  /**
+   * Close store and manager connections
+   */
+  close() {
+    this.store.close();
+    this.manager.close();
+  }
+  // Private helper methods
+  /**
+   * Build generation prompt for AI
+   */
+  buildGenerationPrompt(request) {
+    const parts = [
+      "You are an expert prompt engineer. Generate a high-quality prompt based on these requirements:",
+      "",
+      `Name: ${request.name}`,
+      `Description: ${request.description}`,
+      `Category: ${request.category}`
+    ];
+    if (request.variant) {
+      parts.push(`Strategy: ${request.variant}`);
+    }
+    if (request.goal) {
+      parts.push(`Goal: ${request.goal}`);
+    }
+    if (request.context) {
+      parts.push(`Context: ${request.context}`);
+    }
+    if (request.constraints && request.constraints.length > 0) {
+      parts.push(`Constraints: ${request.constraints.join(", ")}`);
+    }
+    if (request.examples && request.examples.length > 0) {
+      parts.push(`Examples: ${request.examples.join(", ")}`);
+    }
+    if (request.tags && request.tags.length > 0) {
+      parts.push(`Tags: ${request.tags.join(", ")}`);
+    }
+    if (request.basedOn && request.basedOn.length > 0) {
+      parts.push(`Based on templates: ${request.basedOn.join(", ")}`);
+    }
+    parts.push(
+      "",
+      "Requirements:",
+      "1. Create a clear, specific, and actionable prompt",
+      "2. Include explicit instructions and expectations",
+      "3. Specify measurable success criteria",
+      "4. Consider edge cases and error scenarios",
+      "5. Make the prompt self-contained and complete",
+      "",
+      'Output the generated prompt after the marker "GENERATED PROMPT:" on a new line.'
+    );
+    return parts.join("\n");
+  }
+  /**
+   * Parse generated content from AI output
+   */
+  parseGeneratedContent(output) {
+    const markerIndex = output.indexOf("GENERATED PROMPT:");
+    if (markerIndex !== -1) {
+      const afterMarker = output.substring(markerIndex + "GENERATED PROMPT:".length).trim();
+      return afterMarker;
+    }
+    return output.trim();
+  }
+  /**
+   * Calculate confidence for AI-generated content
+   */
+  calculateAIConfidence(content) {
+    let confidence = 0.5;
+    const wordCount = content.split(/\s+/).length;
+    if (wordCount > 200) {
+      confidence += 0.2;
+    } else if (wordCount > 100) {
+      confidence += 0.1;
+    } else if (wordCount < 50) {
+      confidence -= 0.1;
+    }
+    const vagueWords = ["maybe", "perhaps", "possibly", "might", "could", "any", "some"];
+    const vagueCount = vagueWords.filter((word) => content.toLowerCase().includes(word)).length;
+    confidence -= vagueCount * 0.05;
+    const actionableVerbs = [
+      "create",
+      "build",
+      "implement",
+      "generate",
+      "test",
+      "validate",
+      "optimize",
+      "refactor",
+      "design",
+      "analyze"
+    ];
+    const actionCount = actionableVerbs.filter(
+      (verb) => content.toLowerCase().includes(verb)
+    ).length;
+    confidence += Math.min(actionCount * 0.05, 0.2);
+    if (content.includes("-") || content.includes("*")) {
+      confidence += 0.05;
+    }
+    if (/\d+\./.test(content)) {
+      confidence += 0.05;
+    }
+    return Math.max(0, Math.min(1, confidence));
+  }
+  /**
+   * Create prompt ID from name
+   */
+  createPromptId(name) {
+    return name.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  /**
+   * Select the most appropriate template for a request
+   */
+  selectTemplate(request) {
+    if (request.variant) {
+      const templateId = `strategy-${request.variant}`;
+      const template = this.templates.get(templateId);
+      if (template) {
+        return template;
+      }
+    }
+    const categoryTemplates = Array.from(this.templates.values()).filter(
+      (t) => t.category === request.category
+    );
+    if (categoryTemplates.length > 0) {
+      return categoryTemplates[0] ?? null;
+    }
+    return this.templates.get("strategy-conservative") ?? null;
+  }
+  /**
+   * Build prompt content from template and request
+   */
+  buildFromTemplate(template, request) {
+    let content = template.template;
+    for (const placeholder of template.placeholders) {
+      const requestValue = request[placeholder.key];
+      const value = (typeof requestValue === "string" ? requestValue : void 0) || placeholder.defaultValue || (placeholder.required ? `[${placeholder.key.toUpperCase()}]` : "");
+      const pattern = new RegExp(`{{${placeholder.key}}}`, "g");
+      content = content.replace(pattern, () => value);
+    }
+    if (request.goal && !template.placeholders.find((p) => p.key === "goal")) {
+      content = `${request.goal}
+
+${content}`;
+    }
+    if (request.context && content.includes("{{context}}")) {
+      const ctx = `Context:
+${request.context}`;
+      content = content.replace(/{{context}}/g, () => ctx);
+    }
+    if (request.constraints && Array.isArray(request.constraints) && request.constraints.length > 0) {
+      const constraintsText = `Constraints:
+${request.constraints.map((c) => `- ${c}`).join("\n")}`;
+      if (content.includes("{{constraints}}")) {
+        content = content.replace(/{{constraints}}/g, constraintsText);
+      } else {
+        content += `
+
+${constraintsText}`;
+      }
+    }
+    if (request.examples && Array.isArray(request.examples) && request.examples.length > 0) {
+      const examplesText = `
+
+Examples:
+${request.examples.map((ex, i) => `${i + 1}. ${ex}`).join("\n")}`;
+      content += examplesText;
+    }
+    content = content.replace(/{{[^}]+}}/g, "");
+    content = content.replace(/\n\n\n+/g, "\n\n").trim();
+    return content;
+  }
+  /**
+   * Calculate confidence score for template-based generation
+   */
+  calculateTemplateConfidence(template, request) {
+    let confidence = 0.7;
+    const requiredPlaceholders = template.placeholders.filter((p) => p.required);
+    const providedValues = requiredPlaceholders.filter(
+      (p) => request[p.key]
+    );
+    const completenessScore = providedValues.length / requiredPlaceholders.length * 0.2;
+    confidence += completenessScore;
+    if (request.context && request.context.length > 50) {
+      confidence += 0.03;
+    }
+    if (request.constraints && request.constraints.length > 0) {
+      confidence += 0.03;
+    }
+    if (request.examples && request.examples.length > 0) {
+      confidence += 0.04;
+    }
+    return Math.min(1, confidence);
+  }
+  /**
+   * Generate review checklist for prompt
+   */
+  generateReviewChecklist(request, content) {
+    const checklist = [
+      "Verify that the goal is clearly stated",
+      "Check that all requirements are specific and measurable",
+      "Ensure acceptance criteria are well-defined",
+      "Review for potential ambiguities or unclear terms",
+      "Confirm that constraints are reasonable"
+    ];
+    if (request.variant) {
+      checklist.push(`Verify that the prompt follows ${request.variant} strategy principles`);
+    }
+    if (!request.examples || request.examples.length === 0) {
+      checklist.push("Consider adding examples for clarity");
+    }
+    if (!request.context) {
+      checklist.push("Consider adding more context if available");
+    }
+    if (content) {
+      const wordCount = content.split(/\s+/).length;
+      if (wordCount < 50) {
+        checklist.push("Content seems short - consider adding more detail");
+      }
+      if (wordCount > 500) {
+        checklist.push("Content is long - consider if it could be more concise");
+      }
+      const vagueWords = ["maybe", "perhaps", "possibly", "might", "could"];
+      const hasVague = vagueWords.some((word) => content.toLowerCase().includes(word));
+      if (hasVague) {
+        checklist.push("Content contains vague language - consider making it more specific");
+      }
+    }
+    return checklist;
+  }
+};
+
+// src/cli/commands/prompts.ts
+var manager = null;
+var telemetry = null;
+var evaluator = null;
+var optimizer = null;
+function getManager() {
+  if (!manager) {
+    manager = new PromptManager();
+  }
+  return manager;
+}
+function getTelemetry() {
+  if (!telemetry) {
+    telemetry = getTelemetryLogger();
+  }
+  return telemetry;
+}
+function getEvaluator() {
+  if (!evaluator) {
+    evaluator = new PromptEvaluator({ telemetryLogger: getTelemetry() });
+  }
+  return evaluator;
+}
+function getOptimizer() {
+  if (!optimizer) {
+    optimizer = new PromptOptimizer({ telemetryLogger: getTelemetry() });
+  }
+  return optimizer;
+}
+var createAutoOptimizer = (options = {}) => new AutomaticPromptOptimizer({
+  telemetryLogger: getTelemetry(),
+  promptManager: getManager(),
+  ...options
+});
+async function analyzeSinglePrompt(promptId, versionId) {
+  const prompt = getManager().getOrThrow(promptId);
+  let version;
+  if (versionId) {
+    version = getManager().getVersion(versionId);
+    if (!version) {
+      throw new Error(`Version not found: ${versionId}`);
+    }
+    if (version.promptId !== promptId) {
+      throw new Error(`Version ${versionId} does not belong to prompt ${promptId}`);
+    }
+  } else {
+    version = getManager().getActiveVersion(promptId);
+    if (!version) {
+      throw new Error(`No active version found for prompt "${promptId}"`);
+    }
+  }
+  const analysis = await getOptimizer().analyze(version.id);
+  return { prompt, version, analysis };
+}
+async function collectActiveAnalyses(promptIds) {
+  const entries = [];
+  const promptsToAnalyze = promptIds ? promptIds.map((id) => getManager().getOrThrow(id)) : getManager().list({ status: "active" });
+  for (const prompt of promptsToAnalyze) {
+    try {
+      const version = getManager().getActiveVersion(prompt.id);
+      if (!version) {
+        console.log(chalk.yellow(`  Warning: No active version for ${prompt.name}`));
+        continue;
+      }
+      const analysis = await getOptimizer().analyze(version.id);
+      entries.push({ prompt, version, analysis });
+    } catch (error) {
+      console.log(
+        chalk.yellow(`  Warning: Could not analyze ${prompt.name}: ${error.message}`)
+      );
+    }
+  }
+  return entries;
+}
+async function runCreatePromptAction(options) {
+  try {
+    const CreateOptionsSchema = z.object({
+      name: PromptNameSchema,
+      description: z.string().min(1).max(500),
+      category: z.enum(["system", "strategy", "domain", "workflow", "custom"]),
+      file: ExistingFilePathSchema.optional(),
+      text: PromptContentSchema.optional(),
+      variant: z.enum(BUILT_IN_VARIANT_STRATEGIES).optional(),
+      tags: z.string().optional(),
+      author: z.string().min(1).max(100).optional()
+    });
+    const validatedOptions = validateCommandOptions(CreateOptionsSchema, options);
+    let content = validatedOptions.text;
+    if (validatedOptions.file) {
+      content = fs.readFileSync(validatedOptions.file, "utf8");
+    }
+    if (!content) {
+      console.error(chalk.red("Error: Must provide either --file or --text flag"));
+      console.error(
+        chalk.yellow(
+          'Tip: Use --file <path> to read from a file, or --text "content" to provide content directly'
+        )
+      );
+      process.exit(1);
+    }
+    const id = validatedOptions.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const { prompt, version } = await getManager().create({
+      id,
+      name: validatedOptions.name,
+      description: validatedOptions.description,
+      category: validatedOptions.category,
+      initialContent: content,
+      variant: validatedOptions.variant,
+      tags: validatedOptions.tags ? validatedOptions.tags.split(",").map((t) => t.trim()) : [],
+      author: validatedOptions.author
+    });
+    console.log(chalk.green(`OK Created prompt: ${prompt.name}`));
+    console.log(chalk.gray(`  ID: ${prompt.id}`));
+    console.log(chalk.gray(`  Version: ${version?.id || "unknown"}`));
+    console.log(chalk.gray(`  Category: ${prompt.category}`));
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+async function runEditPromptAction(idOrName, options) {
+  try {
+    const EditOptionsSchema = z.object({
+      file: ExistingFilePathSchema.optional(),
+      text: PromptContentSchema.optional(),
+      changelog: z.string().max(500).optional(),
+      author: z.string().min(1).max(100).optional(),
+      activate: BooleanFlagSchema.optional()
+    });
+    const validatedOptions = validateCommandOptions(EditOptionsSchema, options);
+    let content = validatedOptions.text;
+    if (validatedOptions.file) {
+      content = fs.readFileSync(validatedOptions.file, "utf8");
+    }
+    if (!content) {
+      console.error(chalk.red("Error: Must provide either --file or --text flag"));
+      console.error(
+        chalk.yellow(
+          'Tip: Use --file <path> to read from a file, or --text "content" to provide content directly'
+        )
+      );
+      process.exit(1);
+    }
+    const resolved = resolvePromptIdOrName(idOrName);
+    if (!resolved) {
+      console.error(chalk.red(`Error: Prompt not found: ${idOrName}`));
+      process.exit(1);
+    }
+    const version = await getManager().createVersion({
+      promptId: resolved.id,
+      content,
+      changelog: validatedOptions.changelog,
+      author: validatedOptions.author,
+      activate: validatedOptions.activate
+    });
+    console.log(chalk.green(`OK Created new version: ${version.id}`));
+    if (validatedOptions.activate) {
+      console.log(chalk.green("  Activated as current version"));
+    }
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+async function runArchivePromptAction(idOrName) {
+  try {
+    const resolved = resolvePromptIdOrName(idOrName);
+    if (!resolved) {
+      console.error(chalk.red(`Error: Prompt not found: ${idOrName}`));
+      process.exit(1);
+    }
+    const updated = await getManager().archive(resolved.id);
+    console.log(chalk.green(`OK Archived prompt: ${updated.name}`));
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+async function runRestorePromptAction(idOrName) {
+  try {
+    const resolved = resolvePromptIdOrName(idOrName);
+    if (!resolved) {
+      console.error(chalk.red(`Error: Prompt not found: ${idOrName}`));
+      process.exit(1);
+    }
+    const updated = await getManager().restore(resolved.id);
+    console.log(chalk.green(`OK Restored prompt: ${updated.name}`));
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+async function runEvaluatePromptAction(idOrName, options) {
+  try {
+    if (idOrName) {
+      const resolved = resolvePromptIdOrName(idOrName);
+      if (!resolved) {
+        console.error(chalk.red(`Prompt not found: ${idOrName}`));
+        process.exit(1);
+      }
+      const version = getManager().getActiveVersion(resolved.id);
+      if (!version) {
+        console.error(chalk.red("No active version found"));
+        process.exit(1);
+      }
+      const result = await getEvaluator().evaluate(version.id, {}, resolved.variant);
+      console.log(chalk.bold.cyan(`
+Performance: ${resolved.name}
+`));
+      console.log(
+        chalk.gray(
+          `Success Rate: ${(result.performance.successRate * 100).toFixed(1)}% (${result.performance.successfulExecutions}/${result.performance.totalExecutions})`
+        )
+      );
+      console.log(chalk.gray(`Avg Completeness: ${result.performance.avgCompleteness.toFixed(1)}`));
+      console.log(chalk.gray(`Avg Duration: ${result.performance.avgDuration.toFixed(1)}s`));
+      console.log(chalk.gray(`Sample Size: ${result.performance.sampleSize}`));
+      console.log(chalk.gray(`
+Recommendation: ${result.recommendation}`));
+      console.log(chalk.gray(`Rationale: ${result.rationale}`));
+      return;
+    }
+    if (options.all) {
+      console.log(chalk.cyan("Evaluating all prompts...\n"));
+      const promptList = getManager().list({ status: "active" });
+      let evaluated = 0;
+      for (const p of promptList) {
+        const version = getManager().getActiveVersion(p.id);
+        if (!version) continue;
+        try {
+          const result = await getEvaluator().evaluate(version.id, {}, p.variant);
+          console.log(chalk.bold(p.name) + chalk.gray(` (${version.id})`));
+          console.log(
+            chalk.gray(
+              `  Success: ${(result.performance.successRate * 100).toFixed(1)}% | Completeness: ${result.performance.avgCompleteness.toFixed(1)} | Recommendation: ${result.recommendation}`
+            )
+          );
+          evaluated++;
+        } catch (error) {
+          console.log(
+            chalk.yellow(`  Warning: Could not evaluate ${p.name}: ${error.message}`)
+          );
+        }
+      }
+      console.log(chalk.green(`
+OK Evaluated ${evaluated} prompts`));
+      return;
+    }
+    console.error(chalk.red("Error: Must provide --id or --all flag"));
+    console.error(
+      chalk.yellow(
+        "Tip: Use --id <prompt-id> to evaluate a specific prompt, or --all to evaluate all prompts"
+      )
+    );
+    process.exit(1);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+function resolvePromptIdOrName(idOrName) {
+  const direct = getManager().get(idOrName);
+  if (direct) return direct;
+  return getManager().list().find((p) => p.name === idOrName) ?? null;
+}
+function getUnderperformanceIssues(entry) {
+  const issues = [];
+  const performance = entry.analysis.performance;
+  if (performance.sampleSize < 5) {
+    issues.push(`Insufficient data (sample size ${performance.sampleSize}/5)`);
+  }
+  if (performance.successRate < 0.7) {
+    issues.push(`Success rate ${(performance.successRate * 100).toFixed(1)}% below 70% target`);
+  }
+  if (performance.avgCompleteness < 70) {
+    issues.push(`Completeness ${performance.avgCompleteness.toFixed(1)} below 70 target`);
+  }
+  if (performance.avgDuration > 300) {
+    issues.push(`Average duration ${performance.avgDuration.toFixed(0)}s exceeds 300s budget`);
+  }
+  if (entry.analysis.overallScore < 70) {
+    issues.push(`Overall score ${entry.analysis.overallScore.toFixed(1)} below 70`);
+  }
+  return issues;
+}
+function formatPerformanceSummary(analysis) {
+  const performance = analysis.performance;
+  return `Success ${(performance.successRate * 100).toFixed(1)}% | Completeness ${performance.avgCompleteness.toFixed(1)} | Duration ${performance.avgDuration.toFixed(1)}s | Sample ${performance.sampleSize}`;
+}
+function createPromptsCommand() {
+  const prompts = new Command("prompts").description(
+    'Manage prompts, versions, and optimization\n\nExamples:\n  poetic prompts list\n  poetic prompts create --name "My Prompt" --description "..." --category system\n  poetic prompts analyze-suggestions --id prompt-123'
+  ).alias("p");
+  prompts.command("list").alias("ls").description(
+    "List all prompts\n\nExamples:\n  poetic prompts list\n  poetic prompts list --category system --status active\n  poetic prompts list --limit 100"
+  ).option(
+    "-c, --category <category>",
+    "(OPTIONAL) Filter by category\n    Example: --category system"
+  ).option(
+    "-s, --status <status>",
+    "(OPTIONAL) Filter by status (active|archived|template)\n    Example: --status active",
+    "active"
+  ).option(
+    "-v, --variant <variant>",
+    "(OPTIONAL) Filter by variant\n    Example: --variant conservative"
+  ).option("--limit <number>", "(OPTIONAL) Limit results\n    Example: --limit 100", "50").action(async (options) => {
+    try {
+      const ListOptionsSchema = z.object({
+        category: PromptCategorySchema.optional(),
+        status: z.enum(["active", "archived", "template"]).default("active"),
+        variant: z.string().optional(),
+        limit: z.coerce.number().int().positive().max(1e3).default(50)
+      });
+      const validatedOptions = validateCommandOptions(ListOptionsSchema, options);
+      const prompts2 = getManager().list({
+        category: validatedOptions.category,
+        status: validatedOptions.status,
+        variant: validatedOptions.variant,
+        limit: validatedOptions.limit
+      });
+      if (prompts2.length === 0) {
+        console.log(chalk.yellow("No prompts found"));
+        return;
+      }
+      console.log(chalk.bold.cyan(`
+Prompts (${prompts2.length})
+`));
+      for (const prompt of prompts2) {
+        const statusIcon = prompt.status === "active" ? "OK" : "";
+        console.log(chalk.bold(`${statusIcon} ${prompt.name}`) + chalk.gray(` (${prompt.id})`));
+        console.log(chalk.gray(`   ${prompt.description}`));
+        console.log(
+          chalk.gray(
+            `   Category: ${prompt.category} | Status: ${prompt.status} | Version: ${prompt.currentVersion}`
+          )
+        );
+        if (prompt.variant) {
+          console.log(chalk.gray(`   Variant: ${prompt.variant}`));
+        }
+        if (prompt.tags.length > 0) {
+          console.log(chalk.gray(`   Tags: ${prompt.tags.join(", ")}`));
+        }
+        console.log(chalk.gray(`   Used: ${prompt.usageCount} times`));
+        console.log("");
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prompts.command("create").description(
+    'Create a new prompt\n\nExamples:\n  poetic prompts create --name "My Prompt" --description "..." --category system --text "Prompt content"\n  poetic prompts create --name "My Prompt" --description "..." --category system --file prompt.txt'
+  ).requiredOption("-n, --name <name>", '(REQUIRED) Prompt name\n    Example: --name "My Prompt"').requiredOption(
+    "-d, --description <description>",
+    '(REQUIRED) Prompt description\n    Example: --description "Description text"'
+  ).requiredOption(
+    "-c, --category <category>",
+    "(REQUIRED) Category (system|strategy|domain|workflow|custom)\n    Example: --category system"
+  ).option(
+    "-f, --file <file>",
+    "(OPTIONAL) Read prompt content from file\n    Example: --file prompt.txt"
+  ).option(
+    "-t, --text <text>",
+    '(OPTIONAL) Prompt content as text\n    Example: --text "Prompt content here"'
+  ).option(
+    "-v, --variant <variant>",
+    "(OPTIONAL) Variant strategy (conservative|innovative|hybrid|fast)\n    Example: --variant conservative"
+  ).option("--tags <tags>", "(OPTIONAL) Comma-separated tags\n    Example: --tags auth,security").option("-a, --author <author>", '(OPTIONAL) Author name\n    Example: --author "John Doe"').action(async (options) => {
+    try {
+      const CreateOptionsSchema = z.object({
+        name: PromptNameSchema,
+        description: z.string().min(1).max(500),
+        category: z.enum(["system", "strategy", "domain", "workflow", "custom"]),
+        file: ExistingFilePathSchema.optional(),
+        text: PromptContentSchema.optional(),
+        variant: z.enum(BUILT_IN_VARIANT_STRATEGIES).optional(),
+        tags: z.string().optional(),
+        author: z.string().min(1).max(100).optional()
+      });
+      const validatedOptions = validateCommandOptions(CreateOptionsSchema, options);
+      let content = validatedOptions.text;
+      if (validatedOptions.file) {
+        content = fs.readFileSync(validatedOptions.file, "utf8");
+      }
+      if (!content) {
+        console.error(chalk.red("Error: Must provide either --file or --text flag"));
+        console.error(
+          chalk.yellow(
+            'Tip: Use --file <path> to read from a file, or --text "content" to provide content directly'
+          )
+        );
+        process.exit(1);
+      }
+      const id = validatedOptions.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+      const { prompt, version } = await getManager().create({
+        id,
+        name: validatedOptions.name,
+        description: validatedOptions.description,
+        category: validatedOptions.category,
+        initialContent: content,
+        variant: validatedOptions.variant,
+        tags: validatedOptions.tags ? validatedOptions.tags.split(",").map((t) => t.trim()) : [],
+        author: validatedOptions.author
+      });
+      console.log(chalk.green(`OK Created prompt: ${prompt.name}`));
+      console.log(chalk.gray(`  ID: ${prompt.id}`));
+      console.log(chalk.gray(`  Version: ${version?.id || "unknown"}`));
+      console.log(chalk.gray(`  Category: ${prompt.category}`));
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prompts.command("show <id>").description(
+    "Show prompt details and content\n\nExamples:\n  poetic prompts show prompt-123\n  poetic prompts show prompt-123 --version version-456 --metrics"
+  ).option(
+    "-v, --version <version>",
+    "(OPTIONAL) Show specific version\n    Example: --version version-456"
+  ).option("--metrics", "(OPTIONAL) Show performance metrics").action(async (id, options) => {
+    try {
+      const validatedId = validateCommandOptions(PromptIdSchema, id);
+      const ShowOptionsSchema = z.object({
+        version: z.string().optional(),
+        metrics: BooleanFlagSchema.optional()
+      });
+      const validatedOptions = validateCommandOptions(ShowOptionsSchema, options);
+      const prompt = getManager().get(validatedId);
+      if (!prompt) {
+        console.error(chalk.red(`Prompt not found: ${id}`));
+        process.exit(1);
+      }
+      const version = validatedOptions.version ? getManager().getVersion(validatedOptions.version) : getManager().getActiveVersion(validatedId);
+      if (!version) {
+        console.error(chalk.red("Version not found"));
+        process.exit(1);
+      }
+      console.log(chalk.bold.cyan(`
+${prompt.name}
+`));
+      console.log(chalk.gray(`ID: ${prompt.id}`));
+      console.log(chalk.gray(`Description: ${prompt.description}`));
+      console.log(chalk.gray(`Category: ${prompt.category}`));
+      console.log(chalk.gray(`Status: ${prompt.status}`));
+      if (prompt.variant) {
+        console.log(chalk.gray(`Variant: ${prompt.variant}`));
+      }
+      if (prompt.tags.length > 0) {
+        console.log(chalk.gray(`Tags: ${prompt.tags.join(", ")}`));
+      }
+      console.log(chalk.gray(`Current Version: ${prompt.currentVersion}`));
+      console.log(chalk.gray(`Usage Count: ${prompt.usageCount}`));
+      console.log("");
+      console.log(chalk.bold("Content:"));
+      console.log(chalk.white(version.content));
+      console.log("");
+      if (options.metrics) {
+        const result = await getEvaluator().evaluate(version.id, {}, prompt.variant);
+        if (result.performance.sampleSize > 0) {
+          console.log(chalk.bold.cyan("Performance Metrics:\n"));
+          console.log(
+            chalk.gray(
+              `Success Rate: ${(result.performance.successRate * 100).toFixed(1)}% (${result.performance.successfulExecutions}/${result.performance.totalExecutions})`
+            )
+          );
+          console.log(
+            chalk.gray(`Avg Completeness: ${result.performance.avgCompleteness.toFixed(1)}`)
+          );
+          console.log(chalk.gray(`Avg Duration: ${result.performance.avgDuration.toFixed(1)}s`));
+          console.log(chalk.gray(`Sample Size: ${result.performance.sampleSize}`));
+          console.log(chalk.gray(`
+Recommendation: ${result.recommendation}`));
+          console.log(chalk.gray(`Rationale: ${result.rationale}`));
+        } else {
+          console.log(chalk.yellow("No performance data available"));
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prompts.command("edit <id>").description(
+    'Create a new version of a prompt\n\nExamples:\n  poetic prompts edit prompt-123 --text "New content"\n  poetic prompts edit prompt-123 --file new-content.txt --activate'
+  ).option(
+    "-f, --file <file>",
+    "(OPTIONAL) Read new content from file\n    Example: --file new-content.txt"
+  ).option(
+    "-t, --text <text>",
+    '(OPTIONAL) New content as text\n    Example: --text "New content here"'
+  ).option(
+    "--changelog <changelog>",
+    '(OPTIONAL) Changelog message\n    Example: --changelog "Improved clarity"'
+  ).option("-a, --author <author>", '(OPTIONAL) Author name\n    Example: --author "John Doe"').option("--activate", "(OPTIONAL) Activate this version immediately").action(async (id, options) => {
+    try {
+      const validatedId = validateCommandOptions(PromptIdSchema, id);
+      const EditOptionsSchema = z.object({
+        file: ExistingFilePathSchema.optional(),
+        text: PromptContentSchema.optional(),
+        changelog: z.string().max(500).optional(),
+        author: z.string().min(1).max(100).optional(),
+        activate: BooleanFlagSchema.optional()
+      });
+      const validatedOptions = validateCommandOptions(EditOptionsSchema, options);
+      let content = validatedOptions.text;
+      if (validatedOptions.file) {
+        content = fs.readFileSync(validatedOptions.file, "utf8");
+      }
+      if (!content) {
+        console.error(chalk.red("Error: Must provide either --file or --text flag"));
+        console.error(
+          chalk.yellow(
+            'Tip: Use --file <path> to read from a file, or --text "content" to provide content directly'
+          )
+        );
+        process.exit(1);
+      }
+      const version = await getManager().createVersion({
+        promptId: validatedId,
+        content,
+        changelog: validatedOptions.changelog,
+        author: validatedOptions.author,
+        activate: validatedOptions.activate
+      });
+      console.log(chalk.green(`OK Created new version: ${version.id}`));
+      if (validatedOptions.activate) {
+        console.log(chalk.green("  Activated as current version"));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prompts.command("archive <id>").description("Archive a prompt\n\nExamples:\n  poetic prompts archive prompt-123").action(async (id) => {
+    try {
+      const validatedId = validateCommandOptions(PromptIdSchema, id);
+      const updated = await getManager().archive(validatedId);
+      console.log(chalk.green(`OK Archived prompt: ${updated.name}`));
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prompts.command("restore <id>").description("Restore an archived prompt\n\nExamples:\n  poetic prompts restore prompt-123").action(async (id) => {
+    try {
+      const validatedId = validateCommandOptions(PromptIdSchema, id);
+      const updated = await getManager().restore(validatedId);
+      console.log(chalk.green(`OK Restored prompt: ${updated.name}`));
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  prompts.command("evaluate").alias("eval").description(
+    "Evaluate prompt performance from telemetry\n\nExamples:\n  poetic prompts evaluate --id prompt-123\n  poetic prompts evaluate --all"
+  ).option("-i, --id <id>", "(OPTIONAL) Evaluate specific prompt\n    Example: --id prompt-123").option("--all", "(OPTIONAL) Evaluate all prompts").action(async (options) => {
+    try {
+      if (options.id) {
+        const prompt = getManager().get(options.id);
+        if (!prompt) {
+          console.error(chalk.red(`Prompt not found: ${options.id}`));
+          process.exit(1);
+        }
+        const version = getManager().getActiveVersion(options.id);
+        if (!version) {
+          console.error(chalk.red("No active version found"));
+          process.exit(1);
+        }
+        const result = await getEvaluator().evaluate(version.id, {}, prompt.variant);
+        console.log(chalk.bold.cyan(`
+Performance: ${prompt.name}
+`));
+        console.log(
+          chalk.gray(
+            `Success Rate: ${(result.performance.successRate * 100).toFixed(1)}% (${result.performance.successfulExecutions}/${result.performance.totalExecutions})`
+          )
+        );
+        console.log(
+          chalk.gray(`Avg Completeness: ${result.performance.avgCompleteness.toFixed(1)}`)
+        );
+        console.log(chalk.gray(`Avg Duration: ${result.performance.avgDuration.toFixed(1)}s`));
+        console.log(chalk.gray(`Sample Size: ${result.performance.sampleSize}`));
+        console.log(chalk.gray(`
+Recommendation: ${result.recommendation}`));
+        console.log(chalk.gray(`Rationale: ${result.rationale}`));
+      } else if (options.all) {
+        console.log(chalk.cyan("Evaluating all prompts...\n"));
+        const prompts2 = getManager().list({ status: "active" });
+        let evaluated = 0;
+        for (const prompt of prompts2) {
+          const version = getManager().getActiveVersion(prompt.id);
+          if (version) {
+            try {
+              const result = await getEvaluator().evaluate(version.id, {}, prompt.variant);
+              console.log(chalk.bold(prompt.name) + chalk.gray(` (${version.id})`));
+              console.log(
+                chalk.gray(
+                  `  Success: ${(result.performance.successRate * 100).toFixed(1)}% | Completeness: ${result.performance.avgCompleteness.toFixed(1)} | Recommendation: ${result.recommendation}`
+                )
+              );
+              evaluated++;
+            } catch (error) {
+              console.log(
+                chalk.yellow(
+                  `  Warning: Could not evaluate ${prompt.name}: ${error.message}`
+                )
+              );
+            }
+          }
+        }
+        console.log(chalk.green(`
+OK Evaluated ${evaluated} prompts`));
+      } else {
+        console.error(chalk.red("Error: Must provide --id or --all flag"));
+        console.error(
+          chalk.yellow(
+            "Tip: Use --id <prompt-id> to evaluate a specific prompt, or --all to evaluate all prompts"
+          )
+        );
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  const analyzeSuggestionsAction = async (options) => {
+    try {
+      const topN = parseInt(options.top ?? "10", 10);
+      if (Number.isNaN(topN) || topN <= 0) {
+        console.error(chalk.red("Error: --top flag must be a positive integer"));
+        console.error(chalk.yellow("Tip: Use --top 5 to show the top 5 performers"));
+        process.exit(1);
+      }
+      if (options.id) {
+        if (options.all || options.underperforming) {
+          console.error(
+            chalk.red("Error: --id flag cannot be combined with --all or --underperforming flags")
+          );
+          console.error(
+            chalk.yellow("Tip: Use --id alone, or use --all/--underperforming without --id")
+          );
+          process.exit(1);
+        }
+        const entry = await analyzeSinglePrompt(options.id, options.version);
+        console.log(
+          chalk.bold.cyan(`
+Optimization Analysis: ${entry.prompt.name} (${entry.version.id})
+`)
+        );
+        console.log(chalk.gray(`Performance: ${formatPerformanceSummary(entry.analysis)}`));
+        console.log(chalk.gray(`Overall Score: ${entry.analysis.overallScore.toFixed(1)}`));
+        console.log("");
+        if (entry.analysis.suggestions.length === 0) {
+          console.log(chalk.green("No optimization suggestions - prompt looks good!"));
+          return;
+        }
+        for (const suggestion of entry.analysis.suggestions) {
+          const priorityColor = suggestion.priority === "critical" || suggestion.priority === "high" ? chalk.red : suggestion.priority === "medium" ? chalk.yellow : chalk.gray;
+          console.log(
+            priorityColor(`[${suggestion.priority.toUpperCase()}] ${suggestion.description}`)
+          );
+          console.log(chalk.gray(`  Rationale: ${suggestion.rationale}`));
+          console.log(chalk.gray(`  Expected: ${suggestion.expectedImprovement}`));
+          console.log(chalk.gray(`  Effort: ${suggestion.estimatedEffort}`));
+          console.log("");
+        }
+        return;
+      }
+      const analyses = await collectActiveAnalyses();
+      if (options.all) {
+        if (analyses.length === 0) {
+          console.log(chalk.yellow("No active prompts available for analysis."));
+          return;
+        }
+        console.log(chalk.bold.cyan("\nOptimization Report\n"));
+        for (const entry of analyses) {
+          const highPriority = entry.analysis.suggestions.filter(
+            (s) => s.priority === "critical" || s.priority === "high"
+          );
+          console.log(
+            chalk.bold(entry.prompt.name) + chalk.gray(` (${entry.prompt.id}) - ${entry.version.id}`)
+          );
+          console.log(chalk.gray(`  ${formatPerformanceSummary(entry.analysis)}`));
+          console.log(chalk.gray(`  Suggestions: ${entry.analysis.suggestions.length}`));
+          if (highPriority.length > 0) {
+            console.log(chalk.red(`  Warning: ${highPriority.length} high-priority issues`));
+          }
+          console.log("");
+        }
+        console.log(chalk.green(`OK Analyzed ${analyses.length} prompts`));
+        return;
+      }
+      if (options.underperforming) {
+        if (analyses.length === 0) {
+          console.log(chalk.yellow("No active prompts available for analysis."));
+          return;
+        }
+        const underperforming = analyses.map((entry) => ({
+          entry,
+          issues: getUnderperformanceIssues(entry)
+        })).filter((item) => item.issues.length > 0);
+        if (underperforming.length === 0) {
+          console.log(chalk.green("No underperforming prompts detected."));
+          return;
+        }
+        console.log(chalk.bold.cyan("\nWarning: Underperforming Prompts\n"));
+        for (const { entry, issues } of underperforming) {
+          console.log(
+            chalk.bold(entry.prompt.name) + chalk.gray(` (${entry.prompt.id}) - ${entry.version.id}`)
+          );
+          console.log(chalk.gray(`  ${formatPerformanceSummary(entry.analysis)}`));
+          issues.forEach((issue) => {
+            console.log(chalk.yellow(`  - ${issue}`));
+          });
+          console.log("");
+        }
+        console.log(chalk.yellow(`Found ${underperforming.length} prompts needing attention`));
+        return;
+      }
+      if (analyses.length === 0) {
+        console.log(chalk.yellow("No active prompts available for analysis."));
+        return;
+      }
+      const eligible = analyses.filter((entry) => entry.analysis.performance.sampleSize >= 5);
+      if (eligible.length === 0) {
+        console.log(
+          chalk.yellow("No prompts have sufficient data (sample size >= 5) for ranking.")
+        );
+        return;
+      }
+      eligible.sort((a, b) => b.analysis.overallScore - a.analysis.overallScore);
+      const topPerformers = eligible.slice(0, topN);
+      console.log(chalk.bold.cyan(`
+Top ${topPerformers.length} Performing Prompts
+`));
+      topPerformers.forEach((entry, index) => {
+        console.log(
+          chalk.bold(`${index + 1}. ${entry.prompt.name}`) + chalk.gray(
+            ` (${entry.prompt.id}) - ${entry.version.id} | Score ${entry.analysis.overallScore.toFixed(1)}`
+          )
+        );
+        console.log(chalk.gray(`   ${formatPerformanceSummary(entry.analysis)}`));
+      });
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  };
+  const attachAnalyzeSuggestionsOptions = (cmd) => cmd.option("-i, --id <id>", "(OPTIONAL) Analyze specific prompt\n    Example: --id prompt-123").option(
+    "--version <version>",
+    "(OPTIONAL) Analyze specific prompt version (defaults to active)\n    Example: --version version-456"
+  ).option("--all", "(OPTIONAL) Analyze all prompts").option("--underperforming", "(OPTIONAL) Find underperforming prompts").option("--top <n>", "(OPTIONAL) Show top N performers\n    Example: --top 5", "10");
+  attachAnalyzeSuggestionsOptions(
+    prompts.command("analyze-suggestions").description(
+      "Analyze active prompts and emit heuristic suggestions (no provider calls)\n\nExamples:\n  poetic prompts analyze-suggestions --id prompt-123\n  poetic prompts analyze-suggestions --all\n  poetic prompts analyze-suggestions --underperforming --top 5"
+    )
+  ).action(analyzeSuggestionsAction);
+  prompts.command("auto-optimize").description(
+    "Run automatic prompt optimization using telemetry insights\n\nExamples:\n  poetic prompts auto-optimize --id prompt-123\n  poetic prompts auto-optimize --all --auto-activate\n  poetic prompts auto-optimize --id prompt-123 --dry-run"
+  ).option("-i, --id <id>", "(OPTIONAL) Optimize a specific prompt\n    Example: --id prompt-123").option("--all", "(OPTIONAL) Optimize all prompts that need attention").option(
+    "--min-sample-size <n>",
+    "(OPTIONAL) Minimum executions before considering optimization\n    Example: --min-sample-size 20",
+    "10"
+  ).option(
+    "--improvement-threshold <percent>",
+    "(OPTIONAL) Minimum improvement percentage required for activation\n    Example: --improvement-threshold 10",
+    "5"
+  ).option(
+    "--max-variants <n>",
+    "(OPTIONAL) Maximum variants to generate per prompt\n    Example: --max-variants 5",
+    "3"
+  ).option("--auto-activate", "(OPTIONAL) Automatically activate the best variant when safe").option("--enable-auto-tuning", "(OPTIONAL) Enable auto-tuning safety checks before activation").option("--dry-run", "(OPTIONAL) Analyze only without generating new versions").action(async (options) => {
+    try {
+      if (!options.id && !options.all) {
+        console.error(chalk.red("Error: Provide --id or --all flag for auto-optimize"));
+        console.error(
+          chalk.yellow(
+            "Tip: Use --id <prompt-id> to optimize a specific prompt, or --all to optimize all prompts"
+          )
+        );
+        process.exit(1);
+      }
+      const minSampleSize = parseInt(options.minSampleSize, 10);
+      const improvementThreshold = parseFloat(options.improvementThreshold);
+      const maxVariants = parseInt(options.maxVariants, 10);
+      if (Number.isNaN(minSampleSize) || minSampleSize <= 0) {
+        console.error(chalk.red("Error: --min-sample-size flag must be a positive integer"));
+        console.error(
+          chalk.yellow("Tip: Use --min-sample-size 20 to require at least 20 executions")
+        );
+        process.exit(1);
+      }
+      if (Number.isNaN(improvementThreshold)) {
+        console.error(chalk.red("Error: --improvement-threshold flag must be a number"));
+        console.error(
+          chalk.yellow("Tip: Use --improvement-threshold 10 to require 10% improvement")
+        );
+        process.exit(1);
+      }
+      if (Number.isNaN(maxVariants) || maxVariants <= 0) {
+        console.error(chalk.red("Error: --max-variants flag must be a positive integer"));
+        console.error(chalk.yellow("Tip: Use --max-variants 5 to generate up to 5 variants"));
+        process.exit(1);
+      }
+      const autoOptimizer = createAutoOptimizer({
+        minSampleSize,
+        improvementThreshold,
+        maxVariantsPerOptimization: maxVariants,
+        autoActivateBestVariant: Boolean(options.autoActivate),
+        enableAutoTuning: Boolean(options.enableAutoTuning),
+        requireManualReview: !options.autoActivate
+      });
+      if (options.id) {
+        if (options.all) {
+          console.error(chalk.red("Error: --id and --all flags cannot be combined"));
+          console.error(chalk.yellow("Tip: Use either --id <prompt-id> or --all, but not both"));
+          process.exit(1);
+        }
+        if (options.dryRun) {
+          const recommendation = await autoOptimizer.analyzePrompt(options.id);
+          console.log(
+            chalk.bold.cyan(
+              `
+Auto-Optimizer Analysis: ${recommendation.promptId} (${recommendation.currentVersionId})
+`
+            )
+          );
+          console.log(
+            chalk.gray(
+              `Action: ${recommendation.action.replace("_", " ")} | Confidence ${(recommendation.confidence * 100).toFixed(1)}%`
+            )
+          );
+          console.log(chalk.gray(`Rationale: ${recommendation.rationale}`));
+          console.log(
+            chalk.gray(
+              `Performance: Success ${(recommendation.currentPerformance.successRate * 100).toFixed(1)}% | Completeness ${recommendation.currentPerformance.avgCompleteness.toFixed(1)} | Sample ${recommendation.currentPerformance.sampleSize}`
+            )
+          );
+          if (recommendation.suggestions.length > 0) {
+            console.log(chalk.bold("\nSuggestions:"));
+            recommendation.suggestions.slice(0, 5).forEach((suggestion) => {
+              console.log(
+                `- [${suggestion.priority.toUpperCase()}] ${suggestion.description} (${suggestion.expectedImprovement})`
+              );
+            });
+          }
+          if (recommendation.proposedVariants.length > 0) {
+            console.log(chalk.bold("\nSuggested Prompt Revisions:"));
+            recommendation.proposedVariants.forEach((variant) => {
+              console.log(
+                `- ${variant.variantId}: ${variant.description} (${variant.expectedImprovement})`
+              );
+            });
+          }
+          return;
+        }
+        const result = await autoOptimizer.optimizePrompt(options.id);
+        console.log(
+          chalk.bold.cyan(`
+Auto-Optimizer Result: ${result.promptId} (${result.executedAt})
+`)
+        );
+        console.log(chalk.gray(`Success: ${result.success ? "yes" : "no"}`));
+        console.log(
+          chalk.gray(
+            `Suggested prompt revisions: ${result.suggestedPromptRevisions.length} | Activated: ${result.variantsActivated}`
+          )
+        );
+        if (result.improvements.length > 0) {
+          console.log(chalk.green("\nImprovements:"));
+          result.improvements.forEach((item) => {
+            console.log(`  \u2022 ${item}`);
+          });
+        }
+        if (result.warnings.length > 0) {
+          console.log(chalk.yellow("\nWarnings:"));
+          result.warnings.forEach((item) => {
+            console.log(`  \u2022 ${item}`);
+          });
+        }
+        if (result.errors.length > 0) {
+          console.log(chalk.red("\nErrors:"));
+          result.errors.forEach((item) => {
+            console.log(`  \u2022 ${item}`);
+          });
+        }
+        return;
+      }
+      const promptsToProcess = getManager().list({ status: "active" });
+      if (promptsToProcess.length === 0) {
+        console.log(chalk.yellow("No active prompts available for optimization."));
+        return;
+      }
+      if (options.dryRun) {
+        console.log(chalk.bold.cyan("\nAuto-Optimizer Dry Run\n"));
+        for (const prompt of promptsToProcess) {
+          const recommendation = await autoOptimizer.analyzePrompt(prompt.id);
+          console.log(
+            chalk.bold(prompt.name) + chalk.gray(
+              ` (${prompt.id}) \u2014 ${recommendation.currentVersionId} | Action: ${recommendation.action.replace("_", " ")}`
+            )
+          );
+          console.log(chalk.gray(`  Rationale: ${recommendation.rationale}`));
+          console.log(
+            chalk.gray(
+              `  Performance: Success ${(recommendation.currentPerformance.successRate * 100).toFixed(1)}% | Completeness ${recommendation.currentPerformance.avgCompleteness.toFixed(1)} | Sample ${recommendation.currentPerformance.sampleSize}`
+            )
+          );
+        }
+        return;
+      }
+      const batchResult = await autoOptimizer.optimizeAllPrompts();
+      console.log(chalk.bold.cyan("\nAuto-Optimizer Batch Report\n"));
+      console.log(
+        chalk.gray(
+          `Analyzed ${batchResult.analyzed} prompt(s) | Optimized ${batchResult.optimized} prompt(s)`
+        )
+      );
+      for (const result of batchResult.results) {
+        console.log(
+          chalk.bold(result.promptId) + chalk.gray(
+            ` \u2014 Success: ${result.success ? "yes" : "no"} | Suggested prompt revisions: ${result.suggestedPromptRevisions.length} | Activated: ${result.variantsActivated}`
+          )
+        );
+        if (result.improvements.length > 0) {
+          result.improvements.forEach((item) => {
+            console.log(chalk.green(`  \u2022 ${item}`));
+          });
+        }
+        if (result.warnings.length > 0) {
+          result.warnings.forEach((item) => {
+            console.log(chalk.yellow(`  \u2022 ${item}`));
+          });
+        }
+        if (result.errors.length > 0) {
+          result.errors.forEach((item) => {
+            console.log(chalk.red(`  \u2022 ${item}`));
+          });
+        }
+      }
+      if (batchResult.errors.length > 0) {
+        console.log(chalk.red("\nErrors:"));
+        batchResult.errors.forEach((error) => {
+          console.log(`  \u2022 ${error.promptId}: ${error._error}`);
+        });
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  const attachAuthorOptions = (cmd) => cmd.requiredOption(
+    "-n, --name <name>",
+    '(REQUIRED) Prompt name\n    Example: --name "My Prompt"'
+  ).requiredOption(
+    "-g, --goal <goal>",
+    '(REQUIRED) What should this prompt achieve?\n    Example: --goal "Generate authentication code"'
+  ).requiredOption(
+    "-c, --category <category>",
+    "(REQUIRED) Category (system|strategy|domain|workflow|custom)\n    Example: --category system"
+  ).option(
+    "-d, --description <description>",
+    '(OPTIONAL) Prompt description\n    Example: --description "Description text"'
+  ).option(
+    "--context <context>",
+    '(OPTIONAL) Additional context\n    Example: --context "Additional context here"'
+  ).option("--engine <engine>", "(OPTIONAL) AI engine to use\n    Example: --engine claude").option("--model <model>", "(OPTIONAL) Model to use\n    Example: --model auto").option(
+    "-v, --variant <variant>",
+    "(OPTIONAL) Variant strategy\n    Example: --variant conservative"
+  ).option(
+    "--tags <tags>",
+    "(OPTIONAL) Comma-separated tags\n    Example: --tags auth,security"
+  );
+  attachAuthorOptions(
+    prompts.command("author").description(
+      'Author a new prompt with AI (canonical authoring entry).\n\nExamples:\n  poetic prompts author --name "My Prompt" --goal "..." --category system'
+    )
+  ).action(async (options) => {
+    await runAuthorPromptAction(options);
+  });
+  return prompts;
+}
+async function runAuthorPromptAction(options) {
+  try {
+    const engineId = options.engine ?? resolveDefaultProvider(void 0, process.cwd()).value;
+    const engine = registry.get(engineId);
+    if (!engine) {
+      console.error(chalk.red(`Engine not found: ${engineId}`));
+      process.exit(1);
+    }
+    const generator = new PromptGenerator({});
+    const request = {
+      name: options.name,
+      description: options.description || options.goal,
+      category: options.category,
+      goal: options.goal,
+      context: options.context,
+      variant: options.variant,
+      tags: options.tags ? options.tags.split(",").map((t) => t.trim()) : [],
+      model: options.model
+    };
+    console.log(chalk.cyan("Generating prompt with AI...\n"));
+    const result = await generator.generate(request);
+    if (!result.success) {
+      console.error(chalk.red(`Generation failed: ${result.error}`));
+      process.exit(1);
+    }
+    console.log(chalk.green(`OK Generated prompt: ${result.prompt?.name || "Unknown"}`));
+    console.log(chalk.gray(`  ID: ${result.prompt?.id || "Unknown"}`));
+    console.log(chalk.gray(`  Version: ${result.version?.id || "Unknown"}`));
+    console.log(chalk.gray(`  Confidence: ${(result.confidence * 100).toFixed(1)}%`));
+    console.log("");
+    console.log(chalk.bold("Review Checklist:"));
+    result.suggestedReview.forEach((item) => {
+      console.log(chalk.gray(`  ${item}`));
+    });
+    console.log("");
+    console.log(chalk.bold("Generated Content:"));
+    console.log(chalk.white(result.version?.content || "No content generated"));
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+export {
+  normalizeProviderForModelAvailability,
+  getRegistryProviderForModelAvailability,
+  DEFAULT_MODEL_AVAILABILITY,
+  getProvidersWithRouteModelAvailability,
+  hasProviderRouteModelAvailability,
+  getModelsForTierByProvider,
+  getModelFromFallback,
+  runCreatePromptAction,
+  runEditPromptAction,
+  runArchivePromptAction,
+  runRestorePromptAction,
+  runEvaluatePromptAction,
+  createPromptsCommand,
+  runAuthorPromptAction
+};
+//# sourceMappingURL=chunk-4BOP7T6L.js.map