promptpilot 0.1.2 → 0.1.4

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { realpathSync } from "fs";
+import { readFileSync, realpathSync } from "fs";
 import { fileURLToPath } from "url";
 
 // src/errors.ts
@@ -360,13 +360,13 @@ var modeGuidance = {
   clarity: "Improve clarity, remove ambiguity, and keep the request easy for a downstream model to follow.",
   concise: "Minimize token count while preserving user intent, constraints, and expected output.",
   detailed: "Make the request explicit and complete, including structure and success criteria.",
-  structured: "Organize the request into clean sections with compact headings and bullet points where helpful.",
+  structured: "Organize the request into sections only when that improves clarity or token efficiency.",
   persuasive: "Refine wording so the request is compelling and likely to elicit a thoughtful response.",
   compress: "Aggressively compress redundant wording while preserving the meaning and critical constraints.",
   claude_cli: "Optimize specifically for Claude CLI: compact sections, direct instructions, and minimal boilerplate."
 };
 var presetGuidance = {
-  code: "Favor precise technical requirements, edge cases, and expected output format for code tasks.",
+  code: "Favor precise technical requirements, edge cases, expected output format, and a compact inspect-plan-act-test-reflect loop for code tasks.",
   email: "Preserve the sender's goal, tone, and audience; aim for a realistic and usable writing request.",
   essay: "Preserve thesis, structure, and voice guidance while making the prompt clearer.",
   support: "Favor concise issue context, user impact, and desired resolution details.",
@@ -384,6 +384,10 @@ function getOptimizationSystemPrompt(mode, preset) {
     "- Preserve critical constraints and task goals.",
     "- Improve clarity, structure, and downstream usefulness.",
     "- Keep the result compact when the mode requests compression.",
+    "- Do not force sections when direct phrasing is shorter and equally clear.",
+    "- Remove redundancy aggressively when the source prompt repeats the same goal multiple ways.",
+    "- For code tasks, prefer a terse agent brief over narrative prose.",
+    "- For code tasks, structure the prompt around a Karpathy-style loop: inspect, plan, act, test, reflect, repeat.",
     `Mode guidance: ${modeGuidance[mode]}`,
     preset ? `Preset guidance: ${presetGuidance[preset]}` : "Preset guidance: none"
   ].join("\n");
@@ -712,7 +716,11 @@ function tokenize(value) {
   );
 }
 function extractConstraints(value) {
-  return value.split(/\n+/).map((line) => line.trim()).filter((line) => /(must|should|avoid|do not|don't|never|exactly|at most|under|limit|max)/i.test(line)).slice(0, 8);
+  return Array.from(
+    new Set(
+      value.split(/\n+/).flatMap((line) => line.split(/(?<=[.!?])\s+/)).map((line) => line.trim().replace(/^[-*]\s*/, "")).filter((line) => line.length > 0 && line.length <= 180).filter((line) => /(must|should|avoid|do not|don't|never|exactly|at most|under|limit|max|preserve|keep)/i.test(line))
+    )
+  ).slice(0, 8);
 }
 function extractEntities(value) {
   return Array.from(
@@ -834,6 +842,9 @@ var DEFAULT_PROVIDER = "ollama";
 var DEFAULT_MAX_INPUT_TOKENS = 1200;
 var DEFAULT_MAX_CONTEXT_TOKENS = 800;
 var DEFAULT_MAX_TOTAL_TOKENS = 2200;
+var DEFAULT_ROUTING_PRIORITY = "cheapest_adequate";
+var DEFAULT_ROUTING_TOP_K = 3;
+var DEFAULT_WORKLOAD_BIAS = "code_first";
 var PromptOptimizer = class {
   config;
   logger;
@@ -871,6 +882,10 @@ var PromptOptimizer = class {
     const maxInputTokens = input.maxInputTokens ?? this.config.maxInputTokens ?? DEFAULT_MAX_INPUT_TOKENS;
     const maxContextTokens = input.maxContextTokens ?? this.config.maxContextTokens ?? DEFAULT_MAX_CONTEXT_TOKENS;
     const maxTotalTokens = input.maxTotalTokens ?? this.config.maxTotalTokens ?? DEFAULT_MAX_TOTAL_TOKENS;
+    const routingEnabled = input.routingEnabled !== false;
+    const routingPriority = input.routingPriority ?? DEFAULT_ROUTING_PRIORITY;
+    const routingTopK = input.routingTopK ?? DEFAULT_ROUTING_TOP_K;
+    const workloadBias = input.workloadBias ?? DEFAULT_WORKLOAD_BIAS;
     const warnings = [];
     const changes = [];
     const useContext = input.useContext !== false && Boolean(input.sessionId);
@@ -900,6 +915,7 @@ var PromptOptimizer = class {
     );
     let provider = input.bypassOptimization ? "heuristic" : this.config.provider ?? DEFAULT_PROVIDER;
     let model = provider === "ollama" ? this.config.ollamaModel ?? "auto" : "heuristic";
+    let usedPreprocessedFallback = false;
     let optimizedPrompt = originalPrompt;
     let providerWarnings = [];
     let providerChanges = [];
@@ -934,6 +950,11 @@ var PromptOptimizer = class {
         optimizedPrompt = ollamaResult.optimizedPrompt;
         providerWarnings = ollamaResult.warnings;
         providerChanges = ollamaResult.changes;
+        if (ollamaResult.source === "preprocessed") {
+          provider = "heuristic";
+          model = "cheap-preprocess";
+          usedPreprocessedFallback = true;
+        }
       } else if (provider === "ollama") {
         provider = "heuristic";
         model = "heuristic";
@@ -942,7 +963,7 @@ var PromptOptimizer = class {
         ];
       }
     }
-    if (provider === "heuristic") {
+    if (provider === "heuristic" && !usedPreprocessedFallback) {
       const fallback = this.heuristicOptimize({
         input: {
           ...input,
@@ -959,6 +980,22 @@ var PromptOptimizer = class {
     }
     warnings.push(...providerWarnings);
     changes.push(...providerChanges);
+    const routingDecision = await this.routeDownstreamTargets({
+      input: {
+        ...input,
+        prompt: originalPrompt,
+        mode,
+        preset,
+        routingPriority,
+        routingTopK,
+        workloadBias
+      },
+      routingEnabled,
+      routingPriority,
+      routingTopK,
+      workloadBias
+    });
+    warnings.push(...routingDecision.routingWarnings);
     let finalPrompt = composeFinalPrompt({
       optimizedPrompt,
       input: {
@@ -967,7 +1004,8 @@ var PromptOptimizer = class {
         mode,
         preset
       },
-      context: relevantContext
+      context: relevantContext,
+      routingDecision
     });
     let estimatedTokensAfter = {
       prompt: this.estimator.estimateText(optimizedPrompt),
@@ -984,6 +1022,7 @@ var PromptOptimizer = class {
         },
         optimizedPrompt,
         context: relevantContext,
+        routingDecision,
         maxTotalTokens
       });
       finalPrompt = reduced.finalPrompt;
@@ -1019,6 +1058,11 @@ var PromptOptimizer = class {
       mode,
       provider,
       model,
+      selectedTarget: routingDecision.selectedTarget,
+      rankedTargets: routingDecision.rankedTargets,
+      routingReason: routingDecision.routingReason,
+      routingWarnings: routingDecision.routingWarnings,
+      routingProvider: routingDecision.routingProvider,
       warnings,
       changes,
       debugInfo: input.debug ? {
@@ -1027,7 +1071,8 @@ var PromptOptimizer = class {
         estimatedTokensAfter,
         extractedConstraints,
         preset,
-        selectedModel: model
+        selectedModel: model,
+        routingDecision
       } : void 0
     };
   }
@@ -1050,29 +1095,88 @@ var PromptOptimizer = class {
     });
   }
   async tryOllamaOptimization(options) {
+    const preprocessedPrompt = cheapCompress(options.input.prompt);
+    const preprocessedTokenCount = this.estimator.estimateText(preprocessedPrompt);
+    const ultraMode = preprocessedTokenCount > 500;
     try {
       if (!await this.client.isAvailable()) {
-        return null;
+        return {
+          optimizedPrompt: preprocessedPrompt,
+          changes: ["Applied cheap local preprocessing because Ollama was unavailable."],
+          warnings: ["Ollama was unavailable, so PromptPilot kept the cheap preprocessed prompt."],
+          source: "preprocessed"
+        };
+      }
+      const systemPrompt = ultraMode ? `${getOptimizationSystemPrompt(options.input.mode, options.input.preset)}
+Mode: Ultra compression. Minimize tokens aggressively.` : getOptimizationSystemPrompt(options.input.mode, options.input.preset);
+      const optimizationPrompt = buildOptimizationPrompt(
+        {
+          ...options.input,
+          prompt: preprocessedPrompt
+        },
+        options.relevantContext,
+        options.extractedConstraints
+      );
+      const timeoutMs = options.input.timeoutMs ?? this.config.timeoutMs;
+      let optimizedPrompt = "";
+      let responseChanges = [];
+      let responseWarnings = [];
+      try {
+        const response = await this.client.generateJson({
+          systemPrompt,
+          prompt: optimizationPrompt,
+          timeoutMs,
+          model: options.model,
+          temperature: this.config.temperature,
+          format: "json"
+        });
+        optimizedPrompt = normalizeWhitespace(response.optimizedPrompt ?? "");
+        responseChanges = response.changes ?? [];
+        responseWarnings = response.warnings ?? [];
+      } catch {
+        const raw = await this.client.generate({
+          systemPrompt,
+          prompt: optimizationPrompt,
+          timeoutMs,
+          model: options.model,
+          temperature: this.config.temperature
+        });
+        optimizedPrompt = sanitizeTextOptimizationOutput(raw);
+        responseChanges = [`Applied text-only Ollama optimization with ${options.model}.`];
       }
-      const response = await this.client.generateJson({
-        systemPrompt: getOptimizationSystemPrompt(options.input.mode, options.input.preset),
-        prompt: buildOptimizationPrompt(options.input, options.relevantContext, options.extractedConstraints),
-        timeoutMs: options.input.timeoutMs ?? this.config.timeoutMs,
-        model: options.model,
-        temperature: this.config.temperature,
-        format: "json"
-      });
-      const optimizedPrompt = normalizeWhitespace(response.optimizedPrompt ?? "");
       if (!optimizedPrompt) {
-        return null;
+        return {
+          optimizedPrompt: preprocessedPrompt,
+          changes: ["Applied cheap local preprocessing because the model returned an empty optimization."],
+          warnings: ["The local optimizer returned an empty result, so PromptPilot kept the preprocessed prompt."],
+          source: "preprocessed"
+        };
+      }
+      const optimizedTokenCount = this.estimator.estimateText(optimizedPrompt);
+      if (isCompressionSensitiveMode(options.input.mode) && optimizedTokenCount >= preprocessedTokenCount) {
+        return {
+          optimizedPrompt: preprocessedPrompt,
+          changes: [
+            ...responseChanges,
+            "Kept the cheap preprocessed prompt because the model output was not smaller."
+          ],
+          warnings: responseWarnings,
+          source: "preprocessed"
+        };
       }
       return {
         optimizedPrompt,
-        changes: response.changes ?? [`Applied Ollama optimization with ${options.model}.`],
-        warnings: response.warnings ?? []
+        changes: responseChanges.length > 0 ? responseChanges : [`Applied Ollama optimization with ${options.model}.`],
+        warnings: responseWarnings,
+        source: "ollama"
       };
     } catch {
-      return null;
+      return {
+        optimizedPrompt: preprocessedPrompt,
+        changes: ["Applied cheap local preprocessing because Ollama optimization failed."],
+        warnings: ["Ollama optimization failed, so PromptPilot kept the preprocessed prompt."],
+        source: "preprocessed"
+      };
     }
   }
   async resolveOllamaModel(options) {
@@ -1243,17 +1347,146 @@ var PromptOptimizer = class {
       };
     }
   }
+  async routeDownstreamTargets(options) {
+    const availableTargets = normalizeAvailableTargets(options.input.availableTargets ?? []);
+    if (!options.routingEnabled || availableTargets.length === 0) {
+      return {
+        selectedTarget: null,
+        rankedTargets: [],
+        routingReason: null,
+        routingWarnings: [],
+        routingProvider: null
+      };
+    }
+    if (availableTargets.length === 1) {
+      return {
+        selectedTarget: stripInternalTargetFields(availableTargets[0]),
+        rankedTargets: [
+          {
+            ...stripInternalTargetFields(availableTargets[0]),
+            rank: 1,
+            reason: "Only one downstream target was supplied."
+          }
+        ],
+        routingReason: "Only one downstream target was supplied, so it was selected directly.",
+        routingWarnings: [],
+        routingProvider: "direct"
+      };
+    }
+    if (!this.client.listModels) {
+      return {
+        selectedTarget: null,
+        rankedTargets: [],
+        routingReason: null,
+        routingWarnings: [
+          "Downstream target routing requires local Ollama model discovery so a Qwen router can run."
+        ],
+        routingProvider: null
+      };
+    }
+    try {
+      const installedModels = await this.client.listModels();
+      const routerModel = getQwenRouterModel(installedModels, this.config.routerModel);
+      if (!routerModel) {
+        return {
+          selectedTarget: null,
+          rankedTargets: [],
+          routingReason: null,
+          routingWarnings: [
+            "Downstream target routing could not run because no suitable local Qwen router model is installed."
+          ],
+          routingProvider: null
+        };
+      }
+      const response = await this.client.generateJson({
+        model: routerModel,
+        timeoutMs: options.input.timeoutMs ?? this.config.timeoutMs,
+        temperature: 0,
+        format: "json",
+        systemPrompt: buildDownstreamRoutingSystemPrompt(options.routingPriority, options.workloadBias),
+        prompt: JSON.stringify(
+          {
+            objective: "Rank the caller-supplied downstream targets for this prompt and choose the best top target.",
+            prompt: options.input.prompt,
+            task: options.input.task ?? null,
+            mode: options.input.mode,
+            preset: options.input.preset,
+            tone: options.input.tone ?? null,
+            targetHints: options.input.targetHints ?? [],
+            workloadBias: options.workloadBias,
+            routingPriority: options.routingPriority,
+            candidateTargets: availableTargets.map((target) => ({
+              id: target.id,
+              provider: target.provider,
+              model: target.model,
+              label: target.label ?? null,
+              costRank: target.costRank,
+              latencyRank: target.latencyRank,
+              capabilities: target.capabilities,
+              profile: describeDownstreamTarget(target)
+            }))
+          },
+          null,
+          2
+        )
+      });
+      const rankedTargetIds = Array.from(
+        new Set((response.rankedTargetIds ?? []).map((value) => value.trim()).filter(Boolean))
+      ).slice(0, Math.max(1, options.routingTopK));
+      const rankedTargets = rankedTargetIds.map((id, index) => {
+        const target = availableTargets.find((candidate) => candidate.id === id);
+        if (!target) {
+          return null;
+        }
+        return {
+          ...stripInternalTargetFields(target),
+          rank: index + 1,
+          reason: index === 0 ? response.reason?.trim() || "Selected by the local Qwen downstream router." : `Ranked #${index + 1} by the local Qwen downstream router.`
+        };
+      }).filter((value) => value !== null);
+      const selectedTargetId = response.selectedTargetId?.trim();
+      const selectedTargetCandidate = (selectedTargetId && availableTargets.find((candidate) => candidate.id === selectedTargetId)) ?? (rankedTargets[0] ? availableTargets.find(
+        (candidate) => candidate.provider === rankedTargets[0].provider && candidate.model === rankedTargets[0].model && candidate.label === rankedTargets[0].label
+      ) ?? null : null);
+      if (!selectedTargetCandidate || rankedTargets.length === 0) {
+        return {
+          selectedTarget: null,
+          rankedTargets: [],
+          routingReason: null,
+          routingWarnings: [
+            "Downstream target routing returned an invalid selection, so no downstream target was chosen."
+          ],
+          routingProvider: routerModel
+        };
+      }
+      return {
+        selectedTarget: stripInternalTargetFields(selectedTargetCandidate),
+        rankedTargets,
+        routingReason: response.reason?.trim() || "Selected by the local Qwen downstream router.",
+        routingWarnings: [],
+        routingProvider: routerModel
+      };
+    } catch {
+      return {
+        selectedTarget: null,
+        rankedTargets: [],
+        routingReason: null,
+        routingWarnings: [
+          "Downstream target routing could not complete, so no downstream target was selected."
+        ],
+        routingProvider: null
+      };
+    }
+  }
   heuristicOptimize(options) {
-    const lines = [
-      `Request: ${options.input.prompt}`,
-      options.input.task ? `Task type: ${options.input.task}` : "",
-      options.input.tone ? `Tone: ${options.input.tone}` : "",
-      options.input.outputFormat ? `Output format: ${options.input.outputFormat}` : "",
-      options.input.maxLength ? `Maximum length: ${options.input.maxLength}` : "",
-      options.constraints.length ? `Critical constraints: ${options.constraints.join("; ")}` : ""
-    ].filter(Boolean);
+    const isCodeRequest = isCodeFirstRequest(options.input);
+    const lines = isCodeRequest ? buildCodeFirstHeuristicPrompt(options.input, options.constraints) : buildGeneralHeuristicPrompt(options.input, options.constraints);
     const optimizedPrompt = lines.join("\n");
-    const changes = ["Normalized prompt structure for downstream model consumption."];
+    const changes = isCodeRequest ? [
+      "Compressed the prompt into a code-agent brief.",
+      "Removed redundant narrative phrasing.",
+      "Applied a Karpathy-style inspect-plan-act-test-reflect loop."
+    ] : ["Normalized prompt structure for downstream model consumption."];
     if (options.input.mode === "compress" || options.input.mode === "concise") {
       changes.push("Applied concise formatting to reduce token usage.");
     }
@@ -1274,7 +1507,8 @@ var PromptOptimizer = class {
     const finalPrompt = composeFinalPrompt({
       optimizedPrompt: this.estimator.truncateToBudget(options.optimizedPrompt, Math.floor(options.maxTotalTokens * 0.5)),
       input: options.input,
-      context: compactContext
+      context: compactContext,
+      routingDecision: options.routingDecision
     });
     return {
       finalPrompt,
@@ -1333,9 +1567,17 @@ ${contextBlock}`);
   if (constraints.length > 0) {
     sections.push(`Constraints:
 - ${constraints.join("\n- ")}`);
+  }
+  if (isCodeFirstRequest(input.input)) {
+    sections.push(`Execution loop:
+- Inspect the relevant files and current behavior.
+- Plan the smallest safe next step.
+- Act with minimal, reversible changes.
+- Test or validate the result.
+- Reflect on gaps or risks, then repeat.`);
   }
   const desiredOutput = [
-    input.input.targetModel ? `Target model: ${input.input.targetModel}` : "Target model: claude",
+    input.routingDecision.selectedTarget ? `Selected target: ${formatTargetLabel(input.routingDecision.selectedTarget)}` : input.input.targetModel ? `Target model: ${input.input.targetModel}` : "Target model: claude",
     `Mode: ${input.input.mode}`,
     `Preset: ${input.input.preset}`
   ];
@@ -1361,16 +1603,337 @@ function emptyRelevantContext() {
     debugInfo: {}
   };
 }
+function normalizeAvailableTargets(targets) {
+  return targets.map((target, index) => ({
+    ...target,
+    id: `${target.provider}:${target.model}:${index}`,
+    label: target.label ?? `${target.provider}:${target.model}`,
+    capabilities: target.capabilities ?? inferCapabilities(target),
+    costRank: target.costRank ?? index + 1,
+    latencyRank: target.latencyRank ?? index + 1
+  }));
+}
+function stripInternalTargetFields(target) {
+  return {
+    provider: target.provider,
+    model: target.model,
+    label: target.label,
+    capabilities: target.capabilities,
+    costRank: target.costRank,
+    latencyRank: target.latencyRank
+  };
+}
+function buildDownstreamRoutingSystemPrompt(priority, workloadBias) {
+  return [
+    "You are a downstream model router for PromptPilot.",
+    "Return strict JSON only with this shape:",
+    '{"selectedTargetId":"string","rankedTargetIds":["string"],"reason":"string"}',
+    "Choose only from the supplied candidate target IDs.",
+    "Rank up to the requested top targets in best-first order.",
+    `Routing priority: ${priority}.`,
+    `Workload bias: ${workloadBias}.`,
+    "Code-first means ambiguous prompts should default toward coding-capable or agentic-capable targets.",
+    "Explicit email, support, chat, and lightweight writing prompts may prefer cheaper lighter targets.",
+    "Do not invent targets. Do not output prose outside JSON."
+  ].join("\n");
+}
+function inferCapabilities(target) {
+  const lower = `${target.provider} ${target.model} ${target.label ?? ""}`.toLowerCase();
+  const capabilities = /* @__PURE__ */ new Set();
+  if (/code|codex|coder|agent|tool/.test(lower)) {
+    capabilities.add("coding");
+  }
+  if (/agent|tool/.test(lower)) {
+    capabilities.add("agentic");
+    capabilities.add("tool_use");
+  }
+  if (/refactor|coder|codex/.test(lower)) {
+    capabilities.add("refactor");
+  }
+  if (/debug|fix|ci/.test(lower)) {
+    capabilities.add("debugging");
+  }
+  if (/write|email|chat|sonnet|mini/.test(lower)) {
+    capabilities.add("writing");
+  }
+  if (/email/.test(lower)) {
+    capabilities.add("email");
+  }
+  return Array.from(capabilities);
+}
+function describeDownstreamTarget(target) {
+  return [
+    `provider=${target.provider}`,
+    `model=${target.model}`,
+    `label=${target.label}`,
+    `costRank=${target.costRank}`,
+    `latencyRank=${target.latencyRank}`,
+    `capabilities=${target.capabilities?.join(",") || "none"}`
+  ].join("; ");
+}
+function formatTargetLabel(target) {
+  return target.label ?? `${target.provider}:${target.model}`;
+}
+function isCompressionSensitiveMode(mode) {
+  return mode === "compress" || mode === "concise" || mode === "claude_cli";
+}
+function cheapCompress(text) {
+  return normalizeWhitespace(text).replace(/\b(?:please|kindly|just)\b/gi, "").replace(/\bI\s+(?:want|need|would\s+like\s+to)\b/gi, "").replace(/\s+([,.;:!?])/g, "$1").replace(/\s{2,}/g, " ").trim();
+}
+function sanitizeTextOptimizationOutput(raw) {
+  const normalized = normalizeWhitespace(raw);
+  if (!normalized) {
+    return "";
+  }
+  if (!containsReasoningLeak(normalized)) {
+    return stripWrappingQuotes(normalized);
+  }
+  const candidates = raw.split(/\n{2,}/).map((chunk) => stripWrappingQuotes(normalizeWhitespace(chunk))).filter(Boolean).filter((chunk) => !containsReasoningLeak(chunk)).filter((chunk) => !/^(role|task|guidelines|thinking|thinking process|attempt|critique|final decision|analysis)\b/i.test(chunk)).filter((chunk) => !/^[-*]\s/.test(chunk)).filter((chunk) => !/^\d+\.\s/.test(chunk));
+  return candidates.at(-1) ?? stripWrappingQuotes(normalized);
+}
+function containsReasoningLeak(text) {
+  return /(thinking process|analyze the request|drafting the optimized prompt|critique \d|attempt \d|final decision)/i.test(text);
+}
+function stripWrappingQuotes(text) {
+  return text.replace(/^["'`]+|["'`]+$/g, "").trim();
+}
+function isCodeFirstRequest(input) {
+  if (input.task === "code" || input.preset === "code") {
+    return true;
+  }
+  if ((input.targetHints ?? []).some((hint) => ["coding", "agentic", "refactor", "debugging", "tool_use", "architecture"].includes(hint))) {
+    return true;
+  }
+  return /\b(code|coding|repo|repository|refactor|patch|debug|bug|ci|test|typescript|javascript|agent|tool)\b/i.test(
+    input.prompt
+  );
+}
+function buildGeneralHeuristicPrompt(input, constraints) {
+  return [
+    `Request: ${summarizePrompt(input.prompt, 320)}`,
+    input.task ? `Task type: ${input.task}` : "",
+    input.tone ? `Tone: ${input.tone}` : "",
+    input.outputFormat ? `Output format: ${input.outputFormat}` : "",
+    input.maxLength ? `Maximum length: ${input.maxLength}` : "",
+    constraints.length ? `Critical constraints: ${constraints.join("; ")}` : ""
+  ].filter(Boolean);
+}
+function buildCodeFirstHeuristicPrompt(input, constraints) {
+  const deliverables = inferCodeDeliverables(input.prompt);
+  return [
+    `Goal: ${summarizeCodeGoal(input.prompt)}`,
+    input.tone ? `Tone: ${input.tone}` : "",
+    deliverables.length ? `Deliverables:
+- ${deliverables.join("\n- ")}` : "",
+    constraints.length ? `Constraints: ${constraints.join("; ")}` : "",
+    "Use a Karpathy loop: inspect, plan, act, test, reflect, repeat."
+  ].filter(Boolean);
+}
+function summarizePrompt(prompt, maxLength) {
+  const normalized = normalizeWhitespace(prompt);
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength - 1).trim()}\u2026`;
+}
+function summarizeCodeGoal(prompt) {
+  const normalized = summarizePrompt(prompt, 220);
+  const lowered = prompt.toLowerCase();
+  if (/auth|authentication|login|token/.test(lowered)) {
+    return "Inspect the codebase, understand the authentication flow, and produce a safe incremental refactor plan.";
+  }
+  if (/ci|debug|failing|failure|test/.test(lowered)) {
+    return "Inspect the codebase and failing signals, identify root causes, and produce a practical debugging plan.";
+  }
+  if (/refactor/.test(lowered)) {
+    return "Inspect the codebase and produce a phased refactor plan with minimal-risk execution steps.";
+  }
+  return normalized;
+}
+function inferCodeDeliverables(prompt) {
+  const lowered = prompt.toLowerCase();
+  const deliverables = [];
+  if (/inspect|codebase|repo|repository/.test(lowered)) {
+    deliverables.push("Summarize the relevant modules, ownership boundaries, and current behavior.");
+  }
+  if (/shared abstraction|shared abstractions|duplicate|duplicated/.test(lowered)) {
+    deliverables.push("Identify duplicated logic and the best shared abstractions to extract.");
+  }
+  if (/incremental|phase|phased|rollout|step/.test(lowered)) {
+    deliverables.push("Propose an incremental plan with small, reversible steps.");
+  }
+  if (/risk|migration|compatibility|backward/.test(lowered)) {
+    deliverables.push("Call out migration risks, compatibility concerns, and rollback points.");
+  }
+  if (/test|tests/.test(lowered)) {
+    deliverables.push("List the tests or validation needed before and after each phase.");
+  }
+  if (/avoid hand-wavy|practical|concrete/.test(lowered)) {
+    deliverables.push("Keep the recommendations concrete, implementation-oriented, and free of vague architecture advice.");
+  }
+  if (deliverables.length === 0) {
+    deliverables.push("Produce a compact, execution-ready plan for the coding task.");
+  }
+  return deliverables.slice(0, 6);
+}
 
 // src/index.ts
 function createOptimizer(config = {}) {
   return new PromptOptimizer(config);
 }
 
+// src/cliWelcome.ts
+import { basename } from "path";
+var MIN_WIDE_COLUMNS = 84;
+function renderWelcomeScreen(options) {
+  const columns = Math.max(60, options.columns ?? 100);
+  const color = options.color ?? false;
+  const user = options.user?.trim() || "pilot";
+  return columns >= MIN_WIDE_COLUMNS ? renderWideWelcome({ ...options, columns, color, user }) : renderCompactWelcome({ ...options, columns, color, user });
+}
+function renderWideWelcome(options) {
+  const width = clamp(options.columns - 5, 82, 109);
+  const innerWidth = width - 2;
+  const leftWidth = 28;
+  const rightWidth = innerWidth - leftWidth - 5;
+  const leftLines = [
+    style(`Welcome back, ${options.user}`, "bold", options.color),
+    "",
+    ...paintSprite(options.color),
+    "",
+    style(`${options.user} \u2022 ${basename(options.cwd)}`, "dim", options.color),
+    style(options.cwd, "dim", options.color)
+  ];
+  const rightLines = [
+    style("Launchpad", "accent", options.color),
+    "Run " + style('promptpilot optimize "fix this CI failure" --task code --plain', "bold", options.color),
+    "Pipe directly into Claude with " + style("| claude", "bold", options.color),
+    "",
+    style("Custom local model", "accent", options.color),
+    "Use " + style("--model promptpilot-compressor", "bold", options.color) + " for text-only local compression",
+    "",
+    style("Commands", "accent", options.color),
+    "optimize  optimize, compress, and route prompts",
+    "--help    show the full CLI reference"
+  ];
+  const rowCount = Math.max(leftLines.length, rightLines.length);
+  const header = `${style(" PromptPilot ", "accent", options.color)} ${style(`v${options.version}`, "dim", options.color)}`;
+  const topRule = `${style("\u250C", "accent", options.color)}${style("\u2500".repeat(innerWidth), "accent", options.color)}${style("\u2510", "accent", options.color)}`;
+  const bottomRule = `${style("\u2514", "accent", options.color)}${style("\u2500".repeat(innerWidth), "accent", options.color)}${style("\u2518", "accent", options.color)}`;
+  const body = new Array(rowCount).fill(null).map((_, index) => {
+    const left = padVisible(leftLines[index] ?? "", leftWidth);
+    const right = padVisible(rightLines[index] ?? "", rightWidth);
+    return `${style("\u2502", "accent", options.color)} ${left} ${style("\u2502", "accent", options.color)} ${right} ${style("\u2502", "accent", options.color)}`;
+  });
+  const footer = [
+    "",
+    style("Ready when you are.", "dim", options.color),
+    `Run ${style("promptpilot --help", "bold", options.color)} for the full option list.`
+  ];
+  return [header, topRule, ...body, bottomRule, ...footer].join("\n");
+}
+function renderCompactWelcome(options) {
+  const width = clamp(options.columns - 2, 58, 78);
+  const innerWidth = width - 2;
+  const lines = [
+    `${style("PromptPilot", "accent", options.color)} ${style(`v${options.version}`, "dim", options.color)}`,
+    style(`Welcome back, ${options.user}.`, "bold", options.color),
+    ...paintSprite(options.color),
+    style(options.cwd, "dim", options.color),
+    "",
+    style("Quick start", "accent", options.color),
+    'promptpilot optimize "fix this CI failure" --task code --plain',
+    'promptpilot optimize "..." --model promptpilot-compressor',
+    "",
+    style("Help", "accent", options.color),
+    "promptpilot --help"
+  ];
+  return [
+    `${style("\u250C", "accent", options.color)}${style("\u2500".repeat(innerWidth), "accent", options.color)}${style("\u2510", "accent", options.color)}`,
+    ...lines.map((line) => `${style("\u2502", "accent", options.color)} ${padVisible(line, innerWidth - 1)}${style("\u2502", "accent", options.color)}`),
+    `${style("\u2514", "accent", options.color)}${style("\u2500".repeat(innerWidth), "accent", options.color)}${style("\u2518", "accent", options.color)}`
+  ].join("\n");
+}
+function paintSprite(color) {
+  const ink = color ? "\x1B[38;5;215m" : "";
+  const reset = color ? "\x1B[0m" : "";
+  return [
+    `${ink}      .-''''-.${reset}`,
+    `${ink}    .'  .--.  '.${reset}`,
+    `${ink}   /   / oo \\   \\${reset}`,
+    `${ink}  |    \\_==_/    |${reset}`,
+    `${ink}  |   .-.__.-.   |${reset}`,
+    `${ink}   \\  \\_/  \\_/  /${reset}`,
+    `${ink}    '._/|__|\\_.'${reset}`,
+    `${ink}      /_/  \\_\\${reset}`
+  ];
+}
+function style(text, tone, color) {
+  if (!color) {
+    return text;
+  }
+  switch (tone) {
+    case "accent":
+      return `\x1B[38;5;215m${text}\x1B[0m`;
+    case "bold":
+      return `\x1B[1m${text}\x1B[0m`;
+    case "dim":
+      return `\x1B[38;5;245m${text}\x1B[0m`;
+  }
+}
+function padVisible(text, targetWidth) {
+  const truncated = truncateVisible(text, targetWidth);
+  const padding = Math.max(0, targetWidth - visibleWidth(truncated));
+  return `${truncated}${" ".repeat(padding)}`;
+}
+function truncateVisible(text, targetWidth) {
+  if (visibleWidth(text) <= targetWidth) {
+    return text;
+  }
+  let visible = 0;
+  let result = "";
+  let inEscape = false;
+  for (const char of text) {
+    result += char;
+    if (char === "\x1B") {
+      inEscape = true;
+      continue;
+    }
+    if (inEscape) {
+      if (char === "m") {
+        inEscape = false;
+      }
+      continue;
+    }
+    visible += 1;
+    if (visible >= Math.max(0, targetWidth - 1)) {
+      break;
+    }
+  }
+  return `${result}\u2026`;
+}
+function visibleWidth(text) {
+  return text.replace(/\u001b\[[0-9;]*m/g, "").length;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
 // src/cli.ts
-async function runCli(argv, io = { stdout: process.stdout, stderr: process.stderr, stdin: process.stdin }, dependencies = { createOptimizer, readStdin }) {
+async function runCli(argv, io = { stdout: process.stdout, stderr: process.stderr, stdin: process.stdin }, dependencies = { createOptimizer, readStdin, getCliInfo }) {
   const [command, ...rest] = argv;
-  if (!command || command === "--help" || command === "-h") {
+  if (!command) {
+    const info = (dependencies.getCliInfo ?? getCliInfo)(io.stdout);
+    if (io.stdout.isTTY) {
+      io.stdout.write(`${renderWelcomeScreen(info)}
+`);
+      return 0;
+    }
+    io.stdout.write(`${getHelpText()}
+`);
+    return 0;
+  }
+  if (command === "--help" || command === "-h" || command === "help") {
     io.stdout.write(`${getHelpText()}
 `);
     return 0;
@@ -1433,6 +1996,12 @@ async function runCli(argv, io = { stdout: process.stdout, stderr: process.stder
       maxLength: parsed.maxLength,
       tags: parsed.tags,
       pinnedConstraints: parsed.pinnedConstraints,
+      availableTargets: parsed.targets,
+      routingEnabled: parsed.routingEnabled,
+      routingPriority: parsed.routingPriority,
+      routingTopK: parsed.routingTopK,
+      targetHints: parsed.targetHints,
+      workloadBias: parsed.workloadBias,
       debug: parsed.debug,
       plainOutput: parsed.plain,
       maxTotalTokens: parsed.maxTotalTokens,
@@ -1456,6 +2025,10 @@ async function runCli(argv, io = { stdout: process.stdout, stderr: process.stder
 `);
     io.stdout.write(`provider=${result.provider} model=${result.model} tokens=${result.estimatedTokensAfter.total} savings=${result.tokenSavings}
 `);
+    if (result.selectedTarget) {
+      io.stdout.write(`selected_target=${formatTarget(result.selectedTarget)}
+`);
+    }
     if (result.warnings.length > 0) {
       io.stdout.write(`warnings=${result.warnings.join(" | ")}
 `);
@@ -1478,7 +2051,10 @@ function parseOptimizeArgs(args) {
     bypassOptimization: false,
     help: false,
     tags: [],
-    pinnedConstraints: []
+    pinnedConstraints: [],
+    targets: [],
+    targetHints: [],
+    routingEnabled: true
   };
   const positionals = [];
   for (let index = 0; index < args.length; index += 1) {
@@ -1517,6 +2093,24 @@ function parseOptimizeArgs(args) {
       case "--pin-constraint":
         parsed.pinnedConstraints.push(args[++index]);
         break;
+      case "--target":
+        parsed.targets.push(parseTargetCandidate(args[++index], parsed.targets.length));
+        break;
+      case "--target-hint":
+        parsed.targetHints.push(args[++index]);
+        break;
+      case "--routing-priority":
+        parsed.routingPriority = args[++index];
+        break;
+      case "--routing-top-k":
+        parsed.routingTopK = Number(args[++index]);
+        break;
+      case "--workload-bias":
+        parsed.workloadBias = args[++index];
+        break;
+      case "--no-routing":
+        parsed.routingEnabled = false;
+        break;
       case "--host":
         parsed.host = args[++index];
         break;
@@ -1589,6 +2183,12 @@ function getHelpText() {
     "  --max-length <n>",
     "  --tag <value>             Repeatable",
     "  --pin-constraint <text>   Repeatable",
+    "  --target <provider:model> Repeatable",
+    "  --target-hint <value>     Repeatable",
+    "  --routing-priority <value>",
+    "  --routing-top-k <n>",
+    "  --workload-bias <code_first>",
+    "  --no-routing",
     "  --host <url>",
     "  --store <local|sqlite>",
     "  --storage-dir <path>",
@@ -1606,6 +2206,20 @@ function getHelpText() {
     "  --bypass-optimization"
   ].join("\n");
 }
+function parseTargetCandidate(raw, index) {
+  const [provider, ...modelParts] = raw.split(":");
+  const model = modelParts.join(":").trim();
+  return {
+    provider: provider.trim(),
+    model,
+    label: raw,
+    costRank: index + 1,
+    latencyRank: index + 1
+  };
+}
+function formatTarget(target) {
+  return target.label ?? `${target.provider}:${target.model}`;
+}
 async function readStdin(stdin = process.stdin) {
   if (!stdin || stdin.isTTY) {
     return "";
@@ -1620,6 +2234,36 @@ async function readStdin(stdin = process.stdin) {
     stdin.on("error", reject);
   });
 }
+function getCliInfo(stdout) {
+  return {
+    cwd: process.cwd(),
+    version: readPackageVersion(),
+    color: shouldUseColor(stdout),
+    columns: stdout.columns,
+    user: process.env.USER ?? process.env.USERNAME
+  };
+}
+function shouldUseColor(stdout) {
+  if (!stdout.isTTY) {
+    return false;
+  }
+  if (process.env.NO_COLOR) {
+    return false;
+  }
+  if (process.env.TERM === "dumb") {
+    return false;
+  }
+  return true;
+}
+function readPackageVersion() {
+  try {
+    const packageJson = readFileSync(new URL("../package.json", import.meta.url), "utf8");
+    const parsed = JSON.parse(packageJson);
+    return parsed.version ?? "dev";
+  } catch {
+    return "dev";
+  }
+}
 if (isMainModule()) {
   runCli(process.argv.slice(2)).then(
     (code) => {