trip-optimizer 0.1.0

package/dist/cli.js

@@ -0,0 +1,2781 @@
+#!/usr/bin/env node
+import {
+  generateProgram,
+  getGlobalDir,
+  getLearnedPath,
+  getLlmLanguageInstruction,
+  getTripHistoryPath,
+  loadConfig,
+  saveConfig,
+  setLanguage,
+  t
+} from "./chunk-OSZUVWNK.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { input, select, checkbox } from "@inquirer/prompts";
+import chalk from "chalk";
+import ora from "ora";
+import fs3 from "fs";
+import path3 from "path";
+import yaml2 from "js-yaml";
+
+// src/data/profile.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_PROFILE = {
+  loyalty_program: "",
+  dietary: [],
+  stated_vibes: [],
+  learned_vibes: [],
+  anti_patterns: [],
+  anti_patterns_learned: [],
+  source_trust: {},
+  trips_completed: 0,
+  last_debrief: ""
+};
+function loadProfile(dir) {
+  const profilePath = path.join(dir ?? getGlobalDir(), "profile.json");
+  if (!fs.existsSync(profilePath)) return { ...DEFAULT_PROFILE };
+  return JSON.parse(fs.readFileSync(profilePath, "utf-8"));
+}
+function saveProfile(profile, dir) {
+  const d = dir ?? getGlobalDir();
+  fs.mkdirSync(d, { recursive: true });
+  fs.writeFileSync(path.join(d, "profile.json"), JSON.stringify(profile, null, 2));
+}
+
+// src/data/trip.ts
+import fs2 from "fs";
+import path2 from "path";
+import { simpleGit } from "simple-git";
+var GITIGNORE = `results.tsv
+score_history.jsonl
+node_modules/
+`;
+async function scaffoldTrip(tripDir, files) {
+  fs2.mkdirSync(tripDir, { recursive: true });
+  fs2.writeFileSync(path2.join(tripDir, "constraints.yaml"), files.constraints);
+  fs2.writeFileSync(path2.join(tripDir, "rubrics.yaml"), files.rubrics);
+  fs2.writeFileSync(path2.join(tripDir, "plan.md"), files.plan);
+  fs2.writeFileSync(path2.join(tripDir, "program.md"), files.program);
+  fs2.writeFileSync(path2.join(tripDir, "activities_db.json"), "{}");
+  fs2.writeFileSync(path2.join(tripDir, ".gitignore"), GITIGNORE);
+  const git = simpleGit(tripDir);
+  await git.init();
+  await git.add("-A");
+  await git.commit("Initial trip scaffold");
+}
+
+// src/llm/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  client;
+  model;
+  constructor(apiKey, model = "claude-sonnet-4-20250514") {
+    this.client = new Anthropic({ apiKey });
+    this.model = model;
+  }
+  async complete(prompt, maxTokens) {
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      messages: [{ role: "user", content: prompt }]
+    });
+    const block = response.content[0];
+    if (block.type !== "text") throw new Error("Expected text response from LLM");
+    return block.text.trim();
+  }
+};
+
+// src/llm/vertex.ts
+import AnthropicVertex from "@anthropic-ai/vertex-sdk";
+var VertexProvider = class {
+  client;
+  model;
+  constructor(options) {
+    this.client = new AnthropicVertex({
+      projectId: options?.projectId ?? process.env.GOOGLE_CLOUD_PROJECT,
+      region: options?.region ?? process.env.GOOGLE_CLOUD_LOCATION ?? "us-east5"
+    });
+    this.model = options?.model ?? process.env.ANTHROPIC_MODEL ?? "claude-sonnet-4@20250514";
+  }
+  async complete(prompt, maxTokens) {
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      messages: [{ role: "user", content: prompt }]
+    });
+    const block = response.content[0];
+    if (block.type !== "text") throw new Error("Expected text response from LLM");
+    return block.text.trim();
+  }
+};
+
+// src/llm/openai-compatible.ts
+var THINKING_DISABLE_PATTERNS = [
+  /kimi-k2/i,
+  /deepseek-r1/i,
+  /deepseek-reasoner/i
+];
+function supportsThinkingDisable(model) {
+  return THINKING_DISABLE_PATTERNS.some((p) => p.test(model));
+}
+var OpenAICompatibleProvider = class {
+  baseUrl;
+  apiKey;
+  model;
+  reasoning;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.reasoning = supportsThinkingDisable(this.model);
+  }
+  async complete(prompt, maxTokens) {
+    const url = `${this.baseUrl}/chat/completions`;
+    const body = {
+      model: this.model,
+      max_tokens: maxTokens,
+      messages: [{ role: "user", content: prompt }]
+    };
+    if (this.reasoning) {
+      body.thinking = { type: "disabled" };
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const body2 = await response.text();
+      throw new Error(`${this.model} API error ${response.status}: ${body2}`);
+    }
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice?.message) {
+      throw new Error(`Unexpected response from ${this.model}: no message in response`);
+    }
+    const { content, reasoning_content } = choice.message;
+    if (content) {
+      return content.trim();
+    }
+    if (reasoning_content) {
+      throw new Error(
+        `${this.model} exhausted token budget on reasoning (${effectiveMaxTokens} tokens). The model used all tokens for chain-of-thought without producing a final answer. This may resolve on retry, or the prompt may be too complex for the token budget.`
+      );
+    }
+    throw new Error(`${this.model} returned empty response`);
+  }
+};
+
+// src/llm/factory.ts
+function createProvider(config) {
+  if (config.model_override) {
+    const mo = config.model_override;
+    return new OpenAICompatibleProvider({
+      baseUrl: mo.base_url,
+      apiKey: mo.api_key,
+      model: mo.model
+    });
+  }
+  if (process.env.CLAUDE_CODE_USE_VERTEX === "1" || process.env.GOOGLE_CLOUD_PROJECT) {
+    return new VertexProvider();
+  }
+  if (!config.api_key) {
+    throw new Error(
+      "No API key configured and no Vertex AI environment detected.\n  Run: trip-optimizer config set api_key <key>\n  Or set GOOGLE_CLOUD_PROJECT + CLAUDE_CODE_USE_VERTEX=1 for Vertex AI"
+    );
+  }
+  return new AnthropicProvider(config.api_key);
+}
+
+// src/generators/constraints.ts
+import yaml from "js-yaml";
+function generateConstraints(answers) {
+  const startDate = new Date(answers.start_date);
+  const endDate = new Date(answers.end_date);
+  const totalDays = Math.round((endDate.getTime() - startDate.getTime()) / (1e3 * 60 * 60 * 24));
+  const daysPerCity = Math.max(1, Math.floor(totalDays / answers.cities.length));
+  const constraints = {
+    trip: {
+      name: answers.name,
+      start_date: answers.start_date,
+      end_date: answers.end_date,
+      total_days: totalDays,
+      travelers: answers.travelers,
+      origin: answers.origin
+    },
+    cities: answers.cities.map((c) => ({
+      name: c.name,
+      key: c.key,
+      min_days: 1,
+      max_days: Math.min(daysPerCity + 2, totalDays)
+    })),
+    hard_requirements: ["City ordering cannot change"],
+    preferences: {
+      priority_order: answers.vibes,
+      anti_patterns: answers.anti_patterns.length > 0 ? answers.anti_patterns : ["tourist traps", "long queues"],
+      pro_patterns: [
+        "back-alley local spots",
+        "neighborhood wandering with no fixed destination",
+        "things you can only do in this specific place",
+        "seasonal specialties"
+      ]
+    },
+    dietary: answers.dietary,
+    loyalty_program: answers.loyalty_program,
+    budget: {
+      total: answers.budget_total,
+      currency: answers.budget_currency
+    }
+  };
+  return yaml.dump(constraints, { lineWidth: 120, noRefs: true });
+}
+
+// src/generators/rubrics.ts
+var SEED_RUBRIC = `dimensions:
+  experience_quality:
+    weight: 0.25
+    sub_dimensions:
+      authenticity:
+        description: "Are activities local-oriented vs tourist-oriented?"
+        anchors:
+          60: "Multiple tourist traps in the plan"
+          80: "Mostly local-oriented, 1-2 tourist items remain"
+          90: "Every activity feels like a local showed you their city"
+      uniqueness:
+        description: "'Can only do this HERE' experiences"
+        anchors:
+          60: "Activities could be done in any major city"
+          80: "Each city has 1-2 'only here' experiences"
+          90: "Nearly every activity leverages something unique to this place"
+  logistics_efficiency:
+    weight: 0.20
+    sub_dimensions:
+      geographic_clustering:
+        description: "Activities within each day don't zigzag across the city"
+        anchors:
+          60: "Multiple days have morning-east, lunch-north, afternoon-south"
+          80: "Most days are geographically logical"
+          90: "Days are designed as geographic arcs"
+      transit_realism:
+        description: "Specific times, realistic buffers"
+        anchors:
+          60: "Vague transit like 'fly to X' with no details"
+          80: "Most transit has times, some connections lack buffers"
+          90: "Door-to-door timing with buffers for every connection"
+  food_score:
+    weight: 0.15
+    sub_dimensions:
+      regional_authenticity:
+        description: "Local specialties vs generic restaurants"
+        anchors:
+          60: "Hotel buffets and chains for most meals"
+          80: "Mostly local specialties, specific restaurants named"
+          90: "Restaurants are the ones locals queue for"
+  time_allocation:
+    weight: 0.15
+    sub_dimensions:
+      pacing:
+        description: "Not too rushed, not too empty"
+        anchors:
+          60: "Some days have 6 activities, others nothing"
+          80: "Generally steady, a few days overpacked"
+          90: "Natural rhythm \u2014 active mornings, relaxed afternoons"
+  budget_efficiency:
+    weight: 0.10
+    sub_dimensions:
+      value_ratio:
+        description: "High-quality experiences at reasonable cost"
+        anchors:
+          60: "Expensive activities with low enjoyment"
+          80: "Good balance, expensive items justified"
+          90: "Maximizes experience per dollar"
+  accommodation_quality:
+    weight: 0.10
+    sub_dimensions:
+      location_fit:
+        description: "Hotels near the day's key activities"
+        anchors:
+          60: "Hotels in random locations requiring long commutes"
+          80: "Most hotels well-located"
+          90: "Hotel locations chosen WITH the itinerary in mind"
+  transit_realism:
+    weight: 0.05
+    sub_dimensions:
+      specificity:
+        description: "Flight numbers, train types, departure times stated"
+        anchors:
+          60: "Just 'fly to X' with no details"
+          80: "Most transit has times, some still vague"
+          90: "Could book every ticket from this plan"
+
+adversarial_penalties:
+  logistics:
+    - rule: "Transit without specific departure/arrival times"
+      penalty: -3
+    - rule: "Activities scheduled during transit time"
+      penalty: -10
+  experience:
+    - rule: "Tourist trap still in plan"
+      penalty: -8
+    - rule: "Day with zero unstructured time"
+      penalty: -5
+  food:
+    - rule: "Generic 'local restaurant' without specific recommendation"
+      penalty: -3
+    - rule: "Chain restaurant when local alternative exists"
+      penalty: -5
+  realism:
+    - rule: "More than 4 major activities in a single day"
+      penalty: -5
+  max_penalty_per_dimension: -20`;
+async function generateRubrics(provider, constraints, learnedSignals) {
+  const tripSummary = `Trip: ${constraints.trip.name}
+Duration: ${constraints.trip.total_days} days
+Travelers: ${constraints.trip.travelers}
+Cities: ${constraints.cities.map((c) => c.name).join(" \u2192 ")}
+Budget: ${constraints.budget.currency} ${constraints.budget.total}
+Vibes: ${constraints.preferences.priority_order.join(", ")}
+Anti-patterns: ${constraints.preferences.anti_patterns.join(", ")}
+Dietary: ${constraints.dietary.length > 0 ? constraints.dietary.join(", ") : "none"}
+Loyalty program: ${constraints.loyalty_program || "none"}`;
+  const learnedSection = learnedSignals ? `
+## Learned Preferences from Past Trips
+${learnedSignals}
+` : "";
+  const prompt = `Generate a scoring rubric for evaluating this travel plan. The rubric should have 5-7 scoring dimensions, each with 2-4 sub-dimensions. Each sub-dimension needs anchor descriptions at scores 60, 80, and 90.
+
+Also generate adversarial penalty rules that catch specific flaws.
+
+## Trip Details
+${tripSummary}
+${learnedSection}
+
+## Seed Example (adapt dimensions and anchors to fit THIS specific trip)
+\`\`\`yaml
+${SEED_RUBRIC}
+\`\`\`
+
+IMPORTANT:
+- Adapt dimensions to this trip type (e.g., a solo backpacking trip might have "social_opportunities", a family trip might have "kid_friendliness")
+- Dimension weights must sum to 1.0
+- Anchor descriptions should reference specifics of this trip (cities, season, budget level)
+- Keep the same YAML structure as the seed example
+- Return ONLY valid YAML, no other text${getLlmLanguageInstruction()}`;
+  const response = await provider.complete(prompt, 4e3);
+  let yamlText = response;
+  if (yamlText.startsWith("```")) {
+    yamlText = yamlText.split("\n").slice(1).join("\n");
+    const lastBacktick = yamlText.lastIndexOf("```");
+    if (lastBacktick >= 0) {
+      yamlText = yamlText.substring(0, lastBacktick).trim();
+    }
+  }
+  return yamlText;
+}
+
+// src/generators/plan.ts
+async function generatePlan(provider, constraints) {
+  const langInstruction = getLlmLanguageInstruction();
+  const prompt = `Generate a detailed day-by-day travel itinerary for this trip.
+
+## Trip Details
+Name: ${constraints.trip.name}
+Dates: ${constraints.trip.start_date} to ${constraints.trip.end_date} (${constraints.trip.total_days} days)
+Travelers: ${constraints.trip.travelers}
+Origin: ${constraints.trip.origin}
+Cities (in order): ${constraints.cities.map((c) => `${c.name} (${c.min_days}-${c.max_days} days)`).join(" \u2192 ")}
+Budget: ${constraints.budget.currency} ${constraints.budget.total} total
+Preferences: ${constraints.preferences.priority_order.join(", ")}
+Anti-patterns to avoid: ${constraints.preferences.anti_patterns.join(", ")}
+Dietary: ${constraints.dietary.length > 0 ? constraints.dietary.join(", ") : "none"}
+Hotel loyalty: ${constraints.loyalty_program || "none"}
+
+## Requirements
+- Start with YAML frontmatter containing trip metadata
+- Each day should have: morning activity, lunch, afternoon activity, dinner, evening
+- Include specific restaurant recommendations (not generic "local restaurant")
+- Include transit details between cities (transport mode, approximate time)
+- Include hotel recommendations
+- Leave some unstructured time for wandering
+- Be realistic about pacing \u2014 travel days should be light on activities
+
+## Format
+---
+trip_name: "${constraints.trip.name}"
+total_days: ${constraints.trip.total_days}
+start_date: ${constraints.trip.start_date}
+end_date: ${constraints.trip.end_date}
+---
+
+# Day 1: [City] \u2014 [Theme]
+## Morning
+...
+## Lunch
+...
+## Afternoon
+...
+## Dinner
+...
+## Evening
+...
+
+**Hotel:** [Name]
+**Transit:** [if applicable]
+
+Generate the complete itinerary now.${langInstruction}`;
+  return await provider.complete(prompt, 8e3);
+}
+
+// src/commands/init.ts
+function loadExisting(name) {
+  const tripDirName = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  const constraintsPath = path3.resolve(tripDirName, "constraints.yaml");
+  if (!fs3.existsSync(constraintsPath)) return null;
+  try {
+    return yaml2.load(fs3.readFileSync(constraintsPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function vibeChoices() {
+  return [
+    { value: "wandering", name: t("vibe.wandering") },
+    { value: "food", name: t("vibe.food") },
+    { value: "culture", name: t("vibe.culture") },
+    { value: "nature", name: t("vibe.nature") },
+    { value: "adventure", name: t("vibe.adventure") },
+    { value: "relaxation", name: t("vibe.relaxation") },
+    { value: "nightlife", name: t("vibe.nightlife") },
+    { value: "history", name: t("vibe.history") },
+    { value: "shopping", name: t("vibe.shopping") },
+    { value: "family", name: t("vibe.family") },
+    { value: "romantic", name: t("vibe.romantic") }
+  ];
+}
+async function collectAnswers(name, profile) {
+  const startDate = await input({ message: t("trip.start_date") });
+  const endDate = await input({ message: t("trip.end_date") });
+  const travelers = await input({ message: t("trip.travelers"), default: "2" });
+  const origin = await input({ message: t("trip.origin"), default: "Atlanta" });
+  const citiesRaw = await input({
+    message: t("trip.cities"),
+    validate: (v) => v.includes(",") || v.length > 0 || t("trip.cities_validate")
+  });
+  const cities = citiesRaw.split(",").map((c) => {
+    const trimmed = c.trim();
+    const key = trimmed.toLowerCase().replace(/[^a-z0-9]/g, "_");
+    return { name: trimmed, key };
+  });
+  const budgetTotal = await input({ message: t("trip.budget"), default: "5000" });
+  const vibes = await checkbox({
+    message: t("trip.vibes"),
+    choices: vibeChoices()
+  });
+  const antiPatternsRaw = await input({
+    message: t("trip.anti_patterns"),
+    default: profile.anti_patterns_learned.length > 0 ? profile.anti_patterns_learned.join(", ") : ""
+  });
+  const antiPatterns = antiPatternsRaw ? antiPatternsRaw.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  return {
+    name,
+    start_date: startDate,
+    end_date: endDate,
+    travelers: parseInt(travelers, 10),
+    origin,
+    cities,
+    budget_total: parseInt(budgetTotal, 10),
+    budget_currency: "USD",
+    vibes,
+    anti_patterns: antiPatterns,
+    dietary: profile.dietary,
+    loyalty_program: profile.loyalty_program
+  };
+}
+async function editAnswers(name, existing, profile) {
+  console.log(chalk.bold(`  ${t("edit.current_settings")}
+`));
+  console.log(`    ${chalk.dim("1.")} ${t("field.dates")}:          ${chalk.white(`${existing.trip.start_date} \u2192 ${existing.trip.end_date}`)}`);
+  console.log(`    ${chalk.dim("2.")} ${t("field.travelers")}:      ${chalk.white(String(existing.trip.travelers))}`);
+  console.log(`    ${chalk.dim("3.")} ${t("field.origin")}:         ${chalk.white(existing.trip.origin)}`);
+  console.log(`    ${chalk.dim("4.")} ${t("field.cities")}:         ${chalk.white(existing.cities.map((c) => c.name).join(", "))}`);
+  console.log(`    ${chalk.dim("5.")} ${t("field.budget")}:         ${chalk.white(`${existing.budget?.currency || "USD"} ${existing.budget?.total || 5e3}`)}`);
+  console.log(`    ${chalk.dim("6.")} ${t("field.vibes")}:          ${chalk.white(existing.preferences.priority_order.join(", "))}`);
+  console.log(`    ${chalk.dim("7.")} ${t("field.anti_patterns")}:  ${chalk.white(existing.preferences.anti_patterns.join(", ") || "none")}`);
+  console.log();
+  const editChoice = await select({
+    message: t("edit.what_to_do"),
+    choices: [
+      { value: "regenerate", name: t("edit.regenerate") },
+      { value: "edit", name: t("edit.edit_fields") },
+      { value: "restart", name: t("edit.restart") }
+    ]
+  });
+  if (editChoice === "restart") {
+    return collectAnswers(name, profile);
+  }
+  let startDate = existing.trip.start_date;
+  let endDate = existing.trip.end_date;
+  let travelers = existing.trip.travelers;
+  let origin = existing.trip.origin;
+  let cities = existing.cities.map((c) => ({ name: c.name, key: c.key }));
+  let budgetTotal = existing.budget?.total || 5e3;
+  let vibes = existing.preferences.priority_order;
+  let antiPatterns = existing.preferences.anti_patterns;
+  if (editChoice === "edit") {
+    const fieldsToEdit = await checkbox({
+      message: t("edit.which_fields"),
+      choices: [
+        { value: "dates", name: `${t("field.dates")} (${startDate} \u2192 ${endDate})` },
+        { value: "travelers", name: `${t("field.travelers")} (${travelers})` },
+        { value: "origin", name: `${t("field.origin")} (${origin})` },
+        { value: "cities", name: `${t("field.cities")} (${cities.map((c) => c.name).join(", ")})` },
+        { value: "budget", name: `${t("field.budget")} (${budgetTotal})` },
+        { value: "vibes", name: `${t("field.vibes")} (${vibes.join(", ")})` },
+        { value: "anti_patterns", name: `${t("field.anti_patterns")} (${antiPatterns.join(", ") || "none"})` }
+      ]
+    });
+    if (fieldsToEdit.includes("dates")) {
+      startDate = await input({ message: t("trip.start_date"), default: startDate });
+      endDate = await input({ message: t("trip.end_date"), default: endDate });
+    }
+    if (fieldsToEdit.includes("travelers")) {
+      const val = await input({ message: t("trip.travelers"), default: String(travelers) });
+      travelers = parseInt(val, 10);
+    }
+    if (fieldsToEdit.includes("origin")) {
+      origin = await input({ message: t("trip.origin"), default: origin });
+    }
+    if (fieldsToEdit.includes("cities")) {
+      const citiesRaw = await input({
+        message: t("trip.cities"),
+        default: cities.map((c) => c.name).join(", ")
+      });
+      cities = citiesRaw.split(",").map((c) => {
+        const trimmed = c.trim();
+        const key = trimmed.toLowerCase().replace(/[^a-z0-9]/g, "_");
+        return { name: trimmed, key };
+      });
+    }
+    if (fieldsToEdit.includes("budget")) {
+      const val = await input({ message: t("trip.budget"), default: String(budgetTotal) });
+      budgetTotal = parseInt(val, 10);
+    }
+    if (fieldsToEdit.includes("vibes")) {
+      vibes = await checkbox({
+        message: t("trip.vibes"),
+        choices: vibeChoices().map((c) => ({ ...c, checked: vibes.includes(c.value) }))
+      });
+    }
+    if (fieldsToEdit.includes("anti_patterns")) {
+      const raw = await input({
+        message: t("trip.anti_patterns"),
+        default: antiPatterns.join(", ")
+      });
+      antiPatterns = raw ? raw.split(",").map((s) => s.trim()).filter(Boolean) : [];
+    }
+  }
+  return {
+    name,
+    start_date: startDate,
+    end_date: endDate,
+    travelers,
+    origin,
+    cities,
+    budget_total: budgetTotal,
+    budget_currency: "USD",
+    vibes,
+    anti_patterns: antiPatterns,
+    dietary: profile.dietary,
+    loyalty_program: profile.loyalty_program
+  };
+}
+function printProviderErrorHint(cfg, msg) {
+  if (cfg.model_override) {
+    const mo = cfg.model_override;
+    if (msg.includes("401") || msg.includes("403") || msg.includes("Authentication") || msg.includes("Unauthorized")) {
+      console.log(chalk.yellow(`  API key for ${mo.model} is invalid or expired.`));
+      console.log(chalk.yellow(`  Run: trip-optimizer config set model_override.api_key <new-key>`));
+      console.log(chalk.yellow(`  Or re-run: trip-optimizer init "${cfg.model_override.model}" to reconfigure.`));
+    } else if (msg.includes("404") || msg.includes("NOT_FOUND")) {
+      console.log(chalk.yellow(`  Model "${mo.model}" not found at ${mo.base_url}`));
+    }
+  } else if (msg.includes("401") || msg.includes("403") || msg.includes("PERMISSION")) {
+    if (process.env.CLAUDE_CODE_USE_VERTEX === "1" || process.env.GOOGLE_CLOUD_PROJECT) {
+      console.log(chalk.yellow(`  ${t("error.auth_check")}`));
+    } else {
+      console.log(chalk.yellow("  Anthropic API key is invalid. Run: trip-optimizer config set api_key <key>"));
+    }
+  } else if (msg.includes("404") || msg.includes("NOT_FOUND")) {
+    console.log(chalk.yellow(`  ${t("error.model_check")}: ANTHROPIC_MODEL=${process.env.ANTHROPIC_MODEL || "(not set)"}`));
+  }
+}
+async function initCommand(name) {
+  const config = loadConfig();
+  const lang = await select({
+    message: t("init.language"),
+    choices: [
+      { value: "en", name: "English" },
+      { value: "zh", name: "\u4E2D\u6587\uFF08\u7B80\u4F53\uFF09" }
+    ],
+    default: config.language || "en"
+  });
+  setLanguage(lang);
+  config.language = lang;
+  saveConfig(config);
+  console.log(chalk.bold(`
+  ${t("init.title")}: ${name}
+`));
+  const profile = loadProfile();
+  const useVertex = !!(process.env.CLAUDE_CODE_USE_VERTEX === "1" || process.env.GOOGLE_CLOUD_PROJECT);
+  if (!config.api_key && !useVertex) {
+    console.log(chalk.yellow(`  ${t("init.first_time")}
+`));
+    const apiKey = await input({
+      message: t("init.api_key"),
+      validate: (v) => v.length > 0 || t("init.api_key_required")
+    });
+    config.api_key = apiKey;
+    saveConfig(config);
+    console.log(chalk.green(`  ${t("init.api_key_saved")}
+`));
+  } else if (useVertex && !config.api_key) {
+    console.log(chalk.cyan(`  ${t("init.vertex_detected")}
+`));
+  }
+  if (config.model_override) {
+    const mo = config.model_override;
+    const maskedKey = mo.api_key.length > 8 ? mo.api_key.slice(0, 4) + "..." + mo.api_key.slice(-4) : "****";
+    console.log(chalk.cyan(`  Custom model: ${mo.model}`));
+    console.log(chalk.cyan(`  Base URL:     ${mo.base_url}`));
+    console.log(chalk.cyan(`  API key:      ${maskedKey}
+`));
+    const modelAction = await select({
+      message: t("init.model_keep_or_change"),
+      choices: [
+        { value: "keep", name: t("init.model_keep") },
+        { value: "edit", name: t("init.model_edit") },
+        { value: "remove", name: t("init.model_remove") }
+      ]
+    });
+    if (modelAction === "edit") {
+      const model = await input({
+        message: t("init.model_name"),
+        default: mo.model
+      });
+      const baseUrl = await input({
+        message: t("init.model_base_url"),
+        default: mo.base_url,
+        validate: (v) => v.startsWith("http") || "Must be a URL"
+      });
+      const apiKey = await input({
+        message: t("init.model_api_key"),
+        default: mo.api_key,
+        validate: (v) => v.length > 0 || "Required"
+      });
+      config.model_override = { provider_type: "openai-compatible", model, base_url: baseUrl, api_key: apiKey };
+      saveConfig(config);
+      console.log(chalk.green(`  ${t("init.model_saved")}
+`));
+    } else if (modelAction === "remove") {
+      delete config.model_override;
+      saveConfig(config);
+      console.log(chalk.green(`  ${t("init.model_removed")}
+`));
+    }
+  } else {
+    const wantOverride = await select({
+      message: t("init.model_override"),
+      choices: [
+        { value: "no", name: t("init.model_override_no") },
+        { value: "yes", name: t("init.model_override_yes") }
+      ]
+    });
+    if (wantOverride === "yes") {
+      const model = await input({
+        message: t("init.model_name"),
+        validate: (v) => v.length > 0 || "Required"
+      });
+      const baseUrl = await input({
+        message: t("init.model_base_url"),
+        validate: (v) => v.startsWith("http") || "Must be a URL"
+      });
+      const apiKey = await input({
+        message: t("init.model_api_key"),
+        validate: (v) => v.length > 0 || "Required"
+      });
+      config.model_override = { provider_type: "openai-compatible", model, base_url: baseUrl, api_key: apiKey };
+      saveConfig(config);
+      console.log(chalk.green(`
+  ${t("init.model_saved")}`));
+      console.log(chalk.yellow(`  ${t("init.model_note")}
+`));
+    }
+  }
+  const profileNeverSet = profile.loyalty_program === "" && profile.stated_vibes.length === 0 && profile.dietary.length === 0;
+  if (profileNeverSet && !loadExisting(name)) {
+    const loyalty = await select({
+      message: t("profile.loyalty"),
+      choices: [
+        { value: "marriott_bonvoy", name: "Marriott Bonvoy" },
+        { value: "hilton_honors", name: "Hilton Honors" },
+        { value: "ihg_rewards", name: "IHG Rewards" },
+        { value: "hyatt", name: "World of Hyatt" },
+        { value: "none", name: "None" }
+      ]
+    });
+    const dietaryChoices = await checkbox({
+      message: t("profile.dietary"),
+      choices: [
+        { value: "vegetarian", name: "Vegetarian" },
+        { value: "vegan", name: "Vegan" },
+        { value: "halal", name: "Halal" },
+        { value: "kosher", name: "Kosher" },
+        { value: "gluten_free", name: "Gluten-free" },
+        { value: "no_shellfish", name: "No shellfish" },
+        { value: "no_nuts", name: "No nuts" }
+      ]
+    });
+    profile.loyalty_program = loyalty === "none" ? "" : loyalty;
+    profile.dietary = dietaryChoices;
+    saveProfile(profile);
+  }
+  const existing = loadExisting(name);
+  let answers;
+  if (existing) {
+    answers = await editAnswers(name, existing, profile);
+  } else {
+    answers = await collectAnswers(name, profile);
+  }
+  const constraintsYaml = generateConstraints(answers);
+  const constraints = yaml2.load(constraintsYaml);
+  let learnedSignals;
+  const learnedPath = getLearnedPath();
+  if (fs3.existsSync(learnedPath)) {
+    learnedSignals = fs3.readFileSync(learnedPath, "utf-8");
+  }
+  let provider;
+  try {
+    provider = createProvider(config);
+  } catch (err) {
+    console.log(chalk.red(`
+  ${t("error.provider_fail")}: ${err instanceof Error ? err.message : String(err)}
+`));
+    process.exit(1);
+  }
+  const spinner = ora(t("progress.generating_rubrics")).start();
+  let rubricsYaml;
+  try {
+    rubricsYaml = await generateRubrics(provider, constraints, learnedSignals);
+    spinner.succeed(t("progress.rubrics_done"));
+  } catch (err) {
+    spinner.fail(t("progress.rubrics_fail"));
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(chalk.red(`
+  ${msg}`));
+    printProviderErrorHint(config, msg);
+    console.log();
+    process.exit(1);
+  }
+  spinner.start(t("progress.generating_plan"));
+  let planMd;
+  try {
+    planMd = await generatePlan(provider, constraints);
+    spinner.succeed(t("progress.plan_done"));
+  } catch (err) {
+    spinner.fail(t("progress.plan_fail"));
+    console.log(chalk.red(`
+  ${err instanceof Error ? err.message : String(err)}
+`));
+    process.exit(1);
+  }
+  const programMd = generateProgram(constraints, config);
+  const tripDirName = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  const tripDir = path3.resolve(tripDirName);
+  if (fs3.existsSync(tripDir)) {
+    fs3.rmSync(tripDir, { recursive: true, force: true });
+  }
+  spinner.start(t("progress.creating_project"));
+  await scaffoldTrip(tripDir, {
+    constraints: constraintsYaml,
+    rubrics: rubricsYaml,
+    plan: planMd,
+    program: programMd
+  });
+  spinner.succeed(`${t("progress.project_created")} ${chalk.bold(tripDirName)}/`);
+  console.log(`
+  ${chalk.green(t("next.title"))}
+    cd ${tripDirName}
+    ${chalk.dim(t("next.review"))}
+    trip-optimizer run
+`);
+}
+
+// src/commands/config.ts
+import chalk2 from "chalk";
+function configCommand(args) {
+  const config = loadConfig();
+  if (args.length === 0) {
+    console.log(chalk2.bold("\n  Configuration\n"));
+    console.log(`  Provider: ${config.provider}`);
+    console.log(`  API Key: ${config.api_key ? config.api_key.substring(0, 10) + "..." : chalk2.dim("not set")}`);
+    if (config.search_api) {
+      console.log(`  Search API: ${config.search_api.provider}`);
+      console.log(`  Search Key: ${config.search_api.api_key ? config.search_api.api_key.substring(0, 10) + "..." : chalk2.dim("not set")}`);
+    }
+    console.log();
+    return;
+  }
+  if (args[0] === "set" && args.length >= 3) {
+    const key = args[1];
+    const value = args.slice(2).join(" ");
+    if (key === "provider") config.provider = value;
+    else if (key === "api_key") config.api_key = value;
+    else if (key === "search_api.provider") {
+      config.search_api = config.search_api || { provider: "", api_key: "" };
+      config.search_api.provider = value;
+    } else if (key === "search_api.api_key") {
+      config.search_api = config.search_api || { provider: "", api_key: "" };
+      config.search_api.api_key = value;
+    } else {
+      console.log(chalk2.red(`  Unknown config key: ${key}`));
+      return;
+    }
+    saveConfig(config);
+    console.log(chalk2.green(`  Set ${key} = ${key.includes("key") ? value.substring(0, 10) + "..." : value}`));
+    return;
+  }
+  console.log("  Usage: trip-optimizer config [set <key> <value>]");
+}
+
+// src/commands/profile.ts
+import chalk3 from "chalk";
+function profileCommand() {
+  const profile = loadProfile();
+  console.log(chalk3.bold("\n  Travel Profile\n"));
+  console.log(`  Loyalty Program: ${profile.loyalty_program || chalk3.dim("none")}`);
+  console.log(`  Dietary: ${profile.dietary.length > 0 ? profile.dietary.join(", ") : chalk3.dim("none")}`);
+  console.log(`  Stated Vibes: ${profile.stated_vibes.length > 0 ? profile.stated_vibes.join(", ") : chalk3.dim("none")}`);
+  if (profile.learned_vibes.length > 0) {
+    console.log(`  Learned Vibes: ${profile.learned_vibes.join(", ")}`);
+  }
+  if (profile.anti_patterns.length > 0) {
+    console.log(`  Anti-patterns: ${profile.anti_patterns.join(", ")}`);
+  }
+  if (profile.anti_patterns_learned.length > 0) {
+    console.log(`  Learned Anti-patterns: ${profile.anti_patterns_learned.join(", ")}`);
+  }
+  console.log(`  Trips Completed: ${profile.trips_completed}`);
+  if (profile.last_debrief) {
+    console.log(`  Last Debrief: ${profile.last_debrief}`);
+  }
+  if (Object.keys(profile.source_trust).length > 0) {
+    console.log(`  Source Trust:`);
+    for (const [source, trust] of Object.entries(profile.source_trust)) {
+      console.log(`    ${source}: ${trust}`);
+    }
+  }
+  console.log();
+}
+
+// src/commands/score.ts
+import fs4 from "fs";
+import path4 from "path";
+import chalk4 from "chalk";
+import yaml3 from "js-yaml";
+
+// src/scoring/prompts.ts
+function buildRubricText(dimConfig) {
+  const lines = [];
+  const subs = dimConfig.sub_dimensions || {};
+  for (const [subName, subConfig] of Object.entries(subs)) {
+    if (!subConfig) continue;
+    lines.push(`
+### ${subName}: ${subConfig.description || ""}`);
+    const anchors = subConfig.anchors || {};
+    const sortedAnchors = Object.entries(anchors).sort(([a], [b]) => Number(a) - Number(b));
+    for (const [score, desc] of sortedAnchors) {
+      lines.push(`  ${score}: ${desc}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildDimensionPrompt(dimName, dimConfig, planContent) {
+  const rubricText = buildRubricText(dimConfig);
+  const subs = dimConfig.sub_dimensions || {};
+  const subDims = Object.keys(subs);
+  if (subDims.length === 0) {
+    return `Score this travel plan on the dimension: ${dimName}
+
+Score on a 0-100 scale. Do NOT round to multiples of 5.
+
+## Travel Plan
+${planContent}
+
+Respond in this exact JSON format (no other text):
+{"overall": {"score": <0-100>, "note": "<1 sentence>"}}`;
+  }
+  return `Score this travel plan on the dimension: ${dimName}
+
+Score each sub-dimension on a 0-100 scale using the rubric anchors below.
+Do NOT round to multiples of 5 \u2014 use precise scores like 83, 87, 91.
+
+## Rubric Anchors
+${rubricText}
+
+## Travel Plan
+${planContent}
+
+Respond in this exact JSON format (no other text):
+{
+${subDims.map((sd) => `  "${sd}": {"score": <0-100>, "note": "<1 sentence>"}`).join(",\n")}
+}`;
+}
+function buildCriticPrompt(planContent, activitiesDb, rubrics) {
+  const rulesText = [];
+  const penalties = rubrics.adversarial_penalties || {};
+  for (const [category, rules] of Object.entries(penalties)) {
+    if (category === "max_penalty_per_dimension") continue;
+    if (!Array.isArray(rules)) continue;
+    for (const r of rules) {
+      if (!r) continue;
+      rulesText.push(`- [${category.toUpperCase()}] ${r.rule || ""} (penalty: ${r.penalty || -3})`);
+    }
+  }
+  const traps = [];
+  for (const [city, data] of Object.entries(activitiesDb || {})) {
+    if (!data) continue;
+    for (const t2 of data.tourist_traps || []) {
+      traps.push(`- ${city}: ${t2.name}`);
+    }
+  }
+  return `You are a travel plan critic. Your ONLY job is to find flaws.
+Do NOT praise anything. Apply these specific penalty rules:
+
+${rulesText.length > 0 ? rulesText.join("\n") : "(no specific rules defined \u2014 use general travel planning best practices)"}
+
+## Known Tourist Traps (from research database)
+${traps.length > 0 ? traps.join("\n") : "(none researched yet)"}
+
+## The Plan
+${planContent}
+
+Find every violation of the rules above. Be strict and specific.
+For each issue, cite the exact day number and the specific problem.
+
+Return a JSON array of penalties (no other text):
+[{"category": "logistics|experience|food|realism", "day": N, "issue": "specific description", "penalty": -N}]
+
+Return an empty array [] if genuinely no issues found.`;
+}
+function buildHolisticPrompt(allScores) {
+  const scoresSummary = [];
+  for (const [dim, data] of Object.entries(allScores)) {
+    const subs = data.sub_dimensions || {};
+    const subDetail = Object.entries(subs).map(([sd, info]) => `${sd}: ${(info?.score ?? 0).toFixed(0)}`).join(", ");
+    scoresSummary.push(`- ${dim}: ${(data.score ?? 0).toFixed(1)} (weight: ${data.weight}) [${subDetail}]`);
+  }
+  return `You are reviewing scores from independent judges evaluating a travel plan.
+Each judge scored one dimension without seeing the others' results.
+
+Your job: identify where dimensions INTERACT and one judge missed something
+that another judge's context reveals. Adjust +/-5 points max per dimension.
+
+## Current Scores
+${scoresSummary.join("\n")}
+
+Examples of cross-dimension interactions:
+- Food scored high but logistics shows 10hr transit day \u2014 station food is smart, bump food +2
+- Experience scored high but accommodation is far from activities \u2014 experience -3
+- Budget scored well but didn't notice cheaper hotel options available \u2014 budget -2
+
+Return a JSON array of adjustments (no other text):
+[{"dimension": "dim_name", "adjustment": +/-N, "reason": "1 sentence"}]
+
+Max +/-5 per dimension. Return [] if no adjustments needed.`;
+}
+function buildComparativePrompt(oldPlanContent, newPlanContent, mutation, rubrics) {
+  const allSubDims = [];
+  const dims = rubrics.dimensions || {};
+  for (const [dimName, dimConfig] of Object.entries(dims)) {
+    const subs = dimConfig?.sub_dimensions || {};
+    for (const sdName of Object.keys(subs)) {
+      allSubDims.push(`${dimName}.${sdName}`);
+    }
+  }
+  return `You are comparing two versions of a travel plan. A single mutation was applied.
+
+## Mutation Applied
+${mutation}
+
+## PLAN A (before mutation)
+${oldPlanContent}
+
+## PLAN B (after mutation)
+${newPlanContent}
+
+For each sub-dimension below, score the IMPACT of this mutation:
+- Positive (+1 to +5): the mutation improved this aspect
+- Negative (-1 to -5): the mutation hurt this aspect
+- Neutral (0): no meaningful change
+
+IMPORTANT: Most sub-dimensions should be NEUTRAL (0) \u2014 a single mutation
+rarely affects more than 2-3 sub-dimensions. Don't inflate changes.
+
+Sub-dimensions:
+${allSubDims.map((sd) => `- ${sd}`).join("\n")}
+
+Return a JSON object with ONLY affected sub-dimensions (non-zero deltas).
+Omit neutral sub-dimensions.
+
+Example (no other text):
+{"logistics_efficiency.transit_realism": 3, "experience_quality.authenticity": -1}
+
+Return {} if no meaningful impact.`;
+}
+
+// src/llm/json-parser.ts
+function parseJsonResponse(text) {
+  if (text.startsWith("```")) {
+    text = text.split("\n").slice(1).join("\n");
+    const lastBacktick = text.lastIndexOf("```");
+    if (lastBacktick >= 0) {
+      text = text.substring(0, lastBacktick).trim();
+    }
+  }
+  text = text.replace(/:\s*\+(\d)/g, ": $1");
+  try {
+    return JSON.parse(text);
+  } catch {
+  }
+  const objStart = text.indexOf("{");
+  const arrStart = text.indexOf("[");
+  const extractors = [];
+  const extractObject = () => {
+    if (objStart < 0) return void 0;
+    let depth = 0;
+    for (let i = objStart; i < text.length; i++) {
+      if (text[i] === "{") depth++;
+      else if (text[i] === "}") {
+        depth--;
+        if (depth === 0) {
+          try {
+            return JSON.parse(text.substring(objStart, i + 1));
+          } catch {
+            return void 0;
+          }
+        }
+      }
+    }
+    return void 0;
+  };
+  const extractArray = () => {
+    if (arrStart < 0) return void 0;
+    let depth = 0;
+    for (let i = arrStart; i < text.length; i++) {
+      if (text[i] === "[") depth++;
+      else if (text[i] === "]") {
+        depth--;
+        if (depth === 0) {
+          try {
+            return JSON.parse(text.substring(arrStart, i + 1));
+          } catch {
+            return void 0;
+          }
+        }
+      }
+    }
+    return void 0;
+  };
+  if (arrStart >= 0 && (objStart < 0 || arrStart < objStart)) {
+    extractors.push(extractArray, extractObject);
+  } else {
+    extractors.push(extractObject, extractArray);
+  }
+  for (const extractor of extractors) {
+    const result = extractor();
+    if (result !== void 0) return result;
+  }
+  if (arrStart !== void 0 && arrStart >= 0) {
+    const lastClose = text.lastIndexOf("}");
+    if (lastClose > arrStart) {
+      try {
+        return JSON.parse(text.substring(arrStart, lastClose + 1) + "]");
+      } catch {
+      }
+    }
+  }
+  throw new Error(`Could not parse JSON from LLM response: ${text.substring(0, 200)}`);
+}
+
+// src/scoring/dimension-scorer.ts
+async function scoreDimension(provider, dimName, dimConfig, planContent) {
+  const subDimensions = dimConfig.sub_dimensions || {};
+  const prompt = buildDimensionPrompt(dimName, { ...dimConfig, sub_dimensions: subDimensions }, planContent);
+  const response = await provider.complete(prompt, 800);
+  let result;
+  try {
+    result = parseJsonResponse(response);
+  } catch {
+    result = null;
+  }
+  const subDims = Object.keys(subDimensions);
+  const subScores = {};
+  if (subDims.length === 0) {
+    let score = 75;
+    if (result && typeof result === "object") {
+      if (typeof result.overall?.score === "number") {
+        score = result.overall.score;
+      } else {
+        for (const val of Object.values(result)) {
+          if (val && typeof val.score === "number") {
+            score = val.score;
+            break;
+          }
+        }
+      }
+    }
+    subScores["overall"] = { score, note: "single-dimension score" };
+  } else {
+    for (const sd of subDims) {
+      if (result && typeof result === "object" && sd in result) {
+        const s = result[sd];
+        subScores[sd] = {
+          score: typeof s?.score === "number" ? s.score : 75,
+          note: s?.note || ""
+        };
+      } else {
+        subScores[sd] = { score: 75, note: "not scored" };
+      }
+    }
+  }
+  const scores = Object.values(subScores);
+  const dimAvg = scores.length > 0 ? scores.reduce((sum, s) => sum + s.score, 0) / scores.length : 75;
+  return {
+    score: Math.round(dimAvg * 10) / 10,
+    weight: dimConfig.weight,
+    sub_dimensions: subScores
+  };
+}
+
+// src/scoring/critic.ts
+var PENALTY_TO_DIMENSION = {
+  logistics: "logistics_efficiency",
+  experience: "experience_quality",
+  food: "food_score",
+  realism: "transit_realism",
+  accommodation: "accommodation_quality"
+};
+function mapPenaltyToDimension(category) {
+  return PENALTY_TO_DIMENSION[category] || "logistics_efficiency";
+}
+async function runAdversarialCritic(provider, planContent, activitiesDb, rubrics) {
+  const prompt = buildCriticPrompt(planContent, activitiesDb, rubrics);
+  try {
+    const response = await provider.complete(prompt, 2e3);
+    const result = parseJsonResponse(response);
+    if (Array.isArray(result)) return result;
+    return [];
+  } catch (e) {
+    console.warn("WARNING: critic parse failed, returning empty penalties");
+    return [];
+  }
+}
+function applyPenalties(scores, penalties, maxPerDimension = -20) {
+  const penaltyByDim = {};
+  for (const p of penalties) {
+    const dim = mapPenaltyToDimension(p.category);
+    penaltyByDim[dim] = penaltyByDim[dim] || 0;
+    penaltyByDim[dim] = Math.max(penaltyByDim[dim] + p.penalty, maxPerDimension);
+  }
+  for (const [dim, pen] of Object.entries(penaltyByDim)) {
+    if (dim in scores) {
+      scores[dim].penalty = pen;
+      scores[dim].score_before_penalty = scores[dim].score;
+      scores[dim].score = Math.max(0, scores[dim].score + pen);
+    }
+  }
+}
+
+// src/scoring/holistic.ts
+async function runHolisticPass(provider, allScores) {
+  const prompt = buildHolisticPrompt(allScores);
+  try {
+    const response = await provider.complete(prompt, 500);
+    const result = parseJsonResponse(response);
+    if (!Array.isArray(result)) return [];
+    return result.filter((a) => Math.abs(a.adjustment || 0) <= 5);
+  } catch (e) {
+    console.warn("WARNING: holistic parse failed, returning no adjustments");
+    return [];
+  }
+}
+function applyHolisticAdjustments(scores, adjustments) {
+  for (const adj of adjustments) {
+    if (adj.dimension in scores) {
+      scores[adj.dimension].holistic_adjustment = adj.adjustment;
+      scores[adj.dimension].holistic_reason = adj.reason;
+      scores[adj.dimension].score = Math.max(0, Math.min(100, scores[adj.dimension].score + adj.adjustment));
+    }
+  }
+}
+
+// src/scoring/scorer.ts
+var Scorer = class {
+  constructor(provider, model = "unknown") {
+    this.provider = provider;
+    this.model = model;
+  }
+  async scoreAbsolute(planContent, activitiesDb, constraints, rubrics, log = console.log) {
+    const dimensions = rubrics.dimensions || {};
+    const allScores = {};
+    for (const [dimName, dimConfig] of Object.entries(dimensions)) {
+      log(`  Scoring ${dimName}...`);
+      const result = await scoreDimension(this.provider, dimName, dimConfig, planContent);
+      allScores[dimName] = result;
+      log(`  ${dimName}: ${result.score.toFixed(1)}`);
+    }
+    log("  Running adversarial critic...");
+    const penalties = await runAdversarialCritic(this.provider, planContent, activitiesDb, rubrics);
+    log(`  ${penalties.length} penalties found`);
+    const maxPen = typeof rubrics.adversarial_penalties?.max_penalty_per_dimension === "number" ? rubrics.adversarial_penalties.max_penalty_per_dimension : -20;
+    applyPenalties(allScores, penalties, maxPen);
+    log("  Running holistic pass...");
+    const adjustments = await runHolisticPass(this.provider, allScores);
+    log(`  ${adjustments.length} adjustments`);
+    applyHolisticAdjustments(allScores, adjustments);
+    const composite = Object.values(allScores).reduce(
+      (sum, d) => sum + d.weight * d.score,
+      0
+    );
+    return {
+      mode: "absolute",
+      composite_score: Math.round(composite * 100) / 100,
+      components: allScores,
+      penalties,
+      holistic_adjustments: adjustments,
+      scored_at: (/* @__PURE__ */ new Date()).toISOString(),
+      model: this.model
+    };
+  }
+  async scoreComparative(oldPlanContent, newPlanContent, mutation, rubrics, log = console.log) {
+    log("  Comparing plans...");
+    const prompt = buildComparativePrompt(oldPlanContent, newPlanContent, mutation, rubrics);
+    const response = await this.provider.complete(prompt, 500);
+    let deltas = {};
+    try {
+      const parsed = parseJsonResponse(response);
+      if (typeof parsed === "object" && !Array.isArray(parsed)) {
+        deltas = parsed;
+      }
+    } catch {
+      log("  WARNING: comparative parse failed, treating as neutral");
+    }
+    const clamped = {};
+    for (const [key, delta] of Object.entries(deltas)) {
+      if (typeof delta === "number") {
+        clamped[key] = Math.max(-5, Math.min(5, delta));
+      }
+    }
+    const dimensions2 = rubrics.dimensions || {};
+    const dimDeltas = {};
+    for (const [dimName, dimConfig] of Object.entries(dimensions2)) {
+      const subs = dimConfig.sub_dimensions || {};
+      const subCount = Object.keys(subs).length || 1;
+      let dimTotal = 0;
+      const affectedSubs = {};
+      for (const sdName of Object.keys(subs)) {
+        const fullKey = `${dimName}.${sdName}`;
+        const d = clamped[fullKey] || 0;
+        dimTotal += d;
+        if (d !== 0) affectedSubs[fullKey] = d;
+      }
+      dimDeltas[dimName] = {
+        delta: Math.round(dimTotal / subCount * 100) / 100,
+        weight: dimConfig.weight,
+        affected_subs: affectedSubs
+      };
+    }
+    const compositeDelta = Object.values(dimDeltas).reduce(
+      (sum, d) => sum + d.weight * d.delta,
+      0
+    );
+    const nonZero = Object.entries(clamped).filter(([, v]) => v !== 0);
+    const verdict = compositeDelta > 0.05 ? "better" : compositeDelta < -0.05 ? "worse" : "neutral";
+    log(`  ${verdict} (delta: ${compositeDelta >= 0 ? "+" : ""}${compositeDelta.toFixed(2)}, ${nonZero.length} subs affected)`);
+    return {
+      mode: "comparative",
+      verdict,
+      composite_delta: Math.round(compositeDelta * 100) / 100,
+      sub_dimension_deltas: clamped,
+      dimension_deltas: dimDeltas,
+      mutation,
+      scored_at: (/* @__PURE__ */ new Date()).toISOString(),
+      model: this.model
+    };
+  }
+};
+
+// src/commands/score.ts
+async function scoreCommand() {
+  const cwd = process.cwd();
+  const constraintsPath = path4.join(cwd, "constraints.yaml");
+  if (!fs4.existsSync(constraintsPath)) {
+    console.log(chalk4.red("\n  Not in a trip project directory (no constraints.yaml found).\n"));
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const constraints = yaml3.load(fs4.readFileSync(constraintsPath, "utf-8"));
+  const rubrics = yaml3.load(fs4.readFileSync(path4.join(cwd, "rubrics.yaml"), "utf-8"));
+  const planContent = fs4.readFileSync(path4.join(cwd, "plan.md"), "utf-8");
+  let activitiesDb = {};
+  const dbPath = path4.join(cwd, "activities_db.json");
+  if (fs4.existsSync(dbPath)) {
+    activitiesDb = JSON.parse(fs4.readFileSync(dbPath, "utf-8"));
+  }
+  console.log(chalk4.bold(`
+  Scoring ${constraints.trip?.name || "trip"} (absolute mode)...
+`));
+  const provider = createProvider(config);
+  const scorer = new Scorer(provider);
+  const result = await scorer.scoreAbsolute(planContent, activitiesDb, constraints, rubrics);
+  fs4.writeFileSync(path4.join(cwd, "score.json"), JSON.stringify(result, null, 2));
+  console.log(chalk4.bold(`
+  Composite Score: ${result.composite_score.toFixed(2)}/100
+`));
+  console.log(chalk4.bold("  Dimension Scores:"));
+  for (const [dim, data] of Object.entries(result.components)) {
+    const extras = [];
+    if (data.penalty) extras.push(`penalty: ${data.penalty}`);
+    if (data.holistic_adjustment) extras.push(`holistic: ${data.holistic_adjustment > 0 ? "+" : ""}${data.holistic_adjustment}`);
+    const extraStr = extras.length > 0 ? chalk4.dim(` (${extras.join(", ")})`) : "";
+    console.log(`    ${dim}: ${data.score.toFixed(1)} ${chalk4.dim(`(w=${data.weight})`)}${extraStr}`);
+    for (const [sd, info] of Object.entries(data.sub_dimensions)) {
+      console.log(`      ${chalk4.dim(sd)}: ${info.score.toFixed(0)} \u2014 ${chalk4.dim(info.note)}`);
+    }
+  }
+  if (result.penalties.length > 0) {
+    console.log(chalk4.bold(`
+  Adversarial Penalties (${result.penalties.length}):`));
+    for (const p of result.penalties) {
+      console.log(`    Day ${p.day}: ${p.issue} ${chalk4.red(`(${p.penalty})`)}`);
+    }
+  }
+  if (result.holistic_adjustments.length > 0) {
+    console.log(chalk4.bold(`
+  Holistic Adjustments (${result.holistic_adjustments.length}):`));
+    for (const a of result.holistic_adjustments) {
+      console.log(`    ${a.dimension}: ${a.adjustment > 0 ? "+" : ""}${a.adjustment} \u2014 ${a.reason}`);
+    }
+  }
+  console.log(chalk4.dim(`
+  Results written to score.json
+`));
+}
+
+// src/commands/research.ts
+import fs5 from "fs";
+import path5 from "path";
+import chalk5 from "chalk";
+import ora2 from "ora";
+import yaml4 from "js-yaml";
+import { simpleGit as simpleGit2 } from "simple-git";
+
+// src/research/researcher.ts
+async function researchCity(provider, cityKey, cityName, constraints, existingCount = 0) {
+  const monthNames = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ];
+  const monthIndex = parseInt(constraints.trip.start_date.substring(5, 7), 10) - 1;
+  const monthName = monthNames[monthIndex] || "this season";
+  const prompt = `You are a travel researcher. Generate detailed recommendations for ${cityName}.
+
+## Trip Context
+Dates: ${constraints.trip.start_date} to ${constraints.trip.end_date}
+Travelers: ${constraints.trip.travelers}
+Preferences: ${constraints.preferences.priority_order.join(", ")}
+Anti-patterns: ${constraints.preferences.anti_patterns.join(", ")}
+${constraints.dietary.length > 0 ? `Dietary: ${constraints.dietary.join(", ")}` : ""}
+Budget level: ${constraints.budget.currency} ${constraints.budget.total} total for ${constraints.trip.total_days} days
+
+## What to Research
+Generate authentic, local-oriented recommendations:
+
+1. **Activities** (6-8): Hidden gems, unique experiences, seasonal specialties, neighborhoods for wandering. Score each 1-10 on authenticity and uniqueness. NO tourist traps.
+
+2. **Restaurants** (5-7): Local favorites, street food spots, regional specialty restaurants. The kind of place with plastic tables that locals queue for. Score each 1-10.
+
+3. **Neighborhoods for wandering** (3-4): Walkable areas with character, local vibe, no chain stores.
+
+4. **Tourist traps** (2-4): Overrated, overcrowded places to AVOID with reasons why.
+
+5. **Seasonal highlights**: What's special about visiting ${cityName} during ${monthName}.
+
+Return a JSON object matching this exact structure:
+{
+  "activities": [
+    {
+      "name": "Activity name",
+      "name_local": "Local language name or empty string",
+      "type": "vibe|food|culture|nature|adventure|history",
+      "score": 8,
+      "authenticity": 9,
+      "uniqueness": 7,
+      "notes": "Why this is great",
+      "crowd_level": "low|medium|high",
+      "cost_per_person": 0,
+      "currency": "USD",
+      "duration_hours": 2,
+      "location": "Neighborhood or area",
+      "best_time": "morning|afternoon|evening|any",
+      "seasonal": null,
+      "source": "llm_knowledge"
+    }
+  ],
+  "restaurants": [
+    {
+      "name": "Restaurant name",
+      "name_local": "",
+      "cuisine": "Regional cuisine type",
+      "score": 9,
+      "authenticity": 9,
+      "notes": "Why locals love this place",
+      "cost_per_person": 15,
+      "currency": "USD",
+      "location": "Area",
+      "reservation_needed": false,
+      "source": "llm_knowledge"
+    }
+  ],
+  "neighborhoods_for_wandering": [
+    {
+      "name": "Neighborhood name",
+      "vibe_score": 8,
+      "walkability": "excellent|good|moderate",
+      "notes": "What makes this area great for wandering"
+    }
+  ],
+  "tourist_traps": [
+    {
+      "name": "Overrated place",
+      "reason": "Why to skip it"
+    }
+  ],
+  "seasonal_highlights": [
+    "What's special this time of year"
+  ]
+}
+
+Return ONLY the JSON object, no other text.`;
+  const response = await provider.complete(prompt, 4e3);
+  const parsed = parseJsonResponse(response);
+  return {
+    activities: parsed.activities || [],
+    restaurants: parsed.restaurants || [],
+    neighborhoods_for_wandering: parsed.neighborhoods_for_wandering || [],
+    tourist_traps: parsed.tourist_traps || [],
+    seasonal_highlights: parsed.seasonal_highlights || []
+  };
+}
+function mergeResearch(existing, newResearch) {
+  if (!existing) return newResearch;
+  const existingActivityNames = new Set(existing.activities.map((a) => a.name));
+  const existingRestaurantNames = new Set(existing.restaurants.map((r) => r.name));
+  const existingNeighborhoods = new Set(existing.neighborhoods_for_wandering.map((n) => n.name));
+  const existingTraps = new Set(existing.tourist_traps.map((t2) => t2.name));
+  return {
+    activities: [
+      ...existing.activities,
+      ...newResearch.activities.filter((a) => !existingActivityNames.has(a.name))
+    ],
+    restaurants: [
+      ...existing.restaurants,
+      ...newResearch.restaurants.filter((r) => !existingRestaurantNames.has(r.name))
+    ],
+    neighborhoods_for_wandering: [
+      ...existing.neighborhoods_for_wandering,
+      ...newResearch.neighborhoods_for_wandering.filter((n) => !existingNeighborhoods.has(n.name))
+    ],
+    tourist_traps: [
+      ...existing.tourist_traps,
+      ...newResearch.tourist_traps.filter((t2) => !existingTraps.has(t2.name))
+    ],
+    seasonal_highlights: [
+      .../* @__PURE__ */ new Set([...existing.seasonal_highlights, ...newResearch.seasonal_highlights])
+    ]
+  };
+}
+
+// src/commands/research.ts
+async function researchCommand(cityArg) {
+  const cwd = process.cwd();
+  if (!fs5.existsSync(path5.join(cwd, "constraints.yaml"))) {
+    console.log(chalk5.red("\n  Not in a trip project directory.\n"));
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const constraints = yaml4.load(fs5.readFileSync(path5.join(cwd, "constraints.yaml"), "utf-8"));
+  const dbPath = path5.join(cwd, "activities_db.json");
+  let activitiesDb = {};
+  if (fs5.existsSync(dbPath)) {
+    activitiesDb = JSON.parse(fs5.readFileSync(dbPath, "utf-8"));
+  }
+  const provider = createProvider(config);
+  const git = simpleGit2(cwd);
+  let cities = constraints.cities;
+  if (cityArg) {
+    const match = cities.find(
+      (c) => c.key === cityArg.toLowerCase() || c.name.toLowerCase().includes(cityArg.toLowerCase())
+    );
+    if (!match) {
+      console.log(chalk5.red(`
+  City "${cityArg}" not found in constraints. Available: ${cities.map((c) => c.key).join(", ")}
+`));
+      process.exit(1);
+    }
+    cities = [match];
+  }
+  console.log(chalk5.bold(`
+  Researching ${cities.length} cit${cities.length === 1 ? "y" : "ies"}...
+`));
+  for (const city of cities) {
+    const existingCount = (activitiesDb[city.key]?.activities?.length || 0) + (activitiesDb[city.key]?.restaurants?.length || 0);
+    const spinner = ora2(`Researching ${city.name}...`).start();
+    try {
+      const research = await researchCity(provider, city.key, city.name, constraints, existingCount);
+      activitiesDb[city.key] = mergeResearch(activitiesDb[city.key], research);
+      const newActivities = research.activities.length;
+      const newRestaurants = research.restaurants.length;
+      const newTraps = research.tourist_traps.length;
+      spinner.succeed(`${city.name}: +${newActivities} activities, +${newRestaurants} restaurants, ${newTraps} traps identified`);
+    } catch (error) {
+      spinner.fail(`${city.name}: research failed \u2014 ${error.message}`);
+    }
+  }
+  fs5.writeFileSync(dbPath, JSON.stringify(activitiesDb, null, 2));
+  try {
+    await git.add("activities_db.json");
+    await git.commit(`research: updated activities database for ${cities.map((c) => c.name).join(", ")}`);
+    console.log(chalk5.green("\n  Database updated and committed.\n"));
+  } catch {
+    console.log(chalk5.dim("\n  Database updated (no git changes to commit).\n"));
+  }
+}
+
+// src/commands/run.ts
+import path7 from "path";
+import fs8 from "fs";
+import chalk6 from "chalk";
+
+// src/optimizer/loop.ts
+import fs7 from "fs";
+import path6 from "path";
+import yaml5 from "js-yaml";
+import { simpleGit as simpleGit3 } from "simple-git";
+
+// src/optimizer/mutations.ts
+var MUTATION_ROTATION = ["SWAP", "UPGRADE", "REORDER", "SIMPLIFY", "REALLOCATE"];
+function pickMutationType(iteration, consecutiveDiscards) {
+  if (consecutiveDiscards >= 5) return "RESEARCH";
+  return MUTATION_ROTATION[iteration % MUTATION_ROTATION.length];
+}
+function buildMutationPrompt(type, planContent, constraints, activitiesDb, lastScoreNotes) {
+  const cityList = constraints.cities.map((c) => `${c.name} (${c.min_days}-${c.max_days} days)`).join(", ");
+  const dbSummary = Object.entries(activitiesDb).map(([city, data]) => `${city}: ${data.activities?.length || 0} activities, ${data.restaurants?.length || 0} restaurants`).join("\n");
+  const baseContext = `## Current Plan
+${planContent}
+
+## Constraints
+Cities: ${cityList}
+Preferences: ${constraints.preferences.priority_order.join(", ")}
+Anti-patterns: ${constraints.preferences.anti_patterns.join(", ")}
+${constraints.dietary.length > 0 ? `Dietary: ${constraints.dietary.join(", ")}` : ""}
+
+## Activities Database Summary
+${dbSummary || "(empty \u2014 no research done yet)"}
+${lastScoreNotes ? `
+## Last Score Notes
+${lastScoreNotes}` : ""}`;
+  const typePrompts = {
+    SWAP: `Find the lowest-quality or most generic activity in the plan and replace it with a better alternative. Prefer activities that match the traveler's vibe preferences and are unique to the specific city. If the activities database has scored alternatives, use the highest-scored one.`,
+    UPGRADE: `Find a generic or mediocre restaurant recommendation in the plan and replace it with a more authentic, local-favorite option. Prefer specific named restaurants over generic descriptions. The replacement should serve regional cuisine and be the kind of place locals actually eat at.`,
+    REORDER: `Find the day with the worst geographic clustering (activities that zigzag across the city) and reorder them so they flow geographically. Morning activities should be near each other, with a natural arc through the day.`,
+    SIMPLIFY: `Find the most packed day or the weakest activity in the plan and remove it, replacing it with free wandering time in a good neighborhood. Unstructured time for exploring is valuable \u2014 don't feel every hour needs an activity.`,
+    REALLOCATE: `Look at the day allocation across cities. Find a city that feels rushed (too many highlights, too few days) and one that feels slow (padding activities, not enough to do). Move one day from the slow city to the rushed one. Respect min/max day bounds.`,
+    RESEARCH: `Identify the city with the weakest activities or fewest database entries. Generate 5-8 new activity and restaurant recommendations for that city. Focus on hidden gems, local favorites, seasonal specialties, and neighborhoods for wandering. Add them to the activities database, then pick the best one and swap it into the plan.`
+  };
+  return `You are making a single "${type}" mutation to improve this travel plan.
+
+## Task
+${typePrompts[type]}
+
+${baseContext}
+
+## Response Format
+Return a JSON object with exactly these fields:
+{
+  "type": "${type}",
+  "description": "Brief description of what changed (e.g., 'Day 3: replaced Temple X with Yanaka neighborhood walk')",
+  "new_plan": "The COMPLETE updated plan.md content with the mutation applied"${type === "RESEARCH" ? ',\n  "new_activities": "JSON string of new activities to add to the database"' : ""}
+}
+
+IMPORTANT:
+- Make exactly ONE change. Do not modify anything else in the plan.
+- Return the COMPLETE plan content, not just the changed section.
+- Keep all YAML frontmatter intact.
+- The description should be specific enough to understand without reading the full plan.`;
+}
+async function generateMutation(provider, type, planContent, constraints, activitiesDb, lastScoreNotes) {
+  const prompt = buildMutationPrompt(type, planContent, constraints, activitiesDb, lastScoreNotes);
+  const response = await provider.complete(prompt, 1e4);
+  let parsed;
+  try {
+    let text = response;
+    if (text.startsWith("```")) {
+      text = text.split("\n").slice(1).join("\n");
+      const lastBacktick = text.lastIndexOf("```");
+      if (lastBacktick >= 0) text = text.substring(0, lastBacktick).trim();
+    }
+    parsed = JSON.parse(text);
+  } catch {
+    const start = response.indexOf("{");
+    const end = response.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      try {
+        parsed = JSON.parse(response.substring(start, end + 1));
+      } catch {
+        throw new Error("Failed to parse mutation response as JSON");
+      }
+    } else {
+      throw new Error("No JSON found in mutation response");
+    }
+  }
+  return {
+    type: parsed.type || type,
+    description: parsed.description || "Unknown mutation",
+    newPlanContent: parsed.new_plan || planContent
+  };
+}
+
+// src/optimizer/logger.ts
+import fs6 from "fs";
+var HEADER = "iteration	commit	score_before	score_after	delta	status	mutation_type	description";
+function appendResult(resultsPath, log) {
+  if (!fs6.existsSync(resultsPath)) {
+    fs6.writeFileSync(resultsPath, HEADER + "\n");
+  }
+  const line = [
+    log.iteration,
+    log.commit,
+    log.score_before.toFixed(2),
+    log.score_after.toFixed(2),
+    (log.delta >= 0 ? "+" : "") + log.delta.toFixed(2),
+    log.status,
+    log.mutation_type,
+    log.description
+  ].join("	");
+  fs6.appendFileSync(resultsPath, line + "\n");
+}
+function readResults(resultsPath) {
+  if (!fs6.existsSync(resultsPath)) return [];
+  const lines = fs6.readFileSync(resultsPath, "utf-8").split("\n").filter(Boolean);
+  if (lines.length <= 1) return [];
+  return lines.slice(1).map((line) => {
+    const parts = line.split("	");
+    return {
+      iteration: parseInt(parts[0], 10),
+      commit: parts[1],
+      score_before: parseFloat(parts[2]),
+      score_after: parseFloat(parts[3]),
+      delta: parseFloat(parts[4]),
+      status: parts[5],
+      mutation_type: parts[6],
+      description: parts[7] || ""
+    };
+  });
+}
+function getLastBestScore(resultsPath) {
+  const results = readResults(resultsPath);
+  if (results.length === 0) return null;
+  for (let i = results.length - 1; i >= 0; i--) {
+    if (results[i].status === "keep") {
+      return { score: results[i].score_after, iteration: results[i].iteration };
+    }
+  }
+  return { score: results[0].score_after, iteration: results[0].iteration };
+}
+
+// src/optimizer/loop.ts
+async function runOptimizationLoop(options) {
+  const {
+    provider,
+    tripDir,
+    recalibrationInterval = 10,
+    onIteration
+  } = options;
+  const git = simpleGit3(tripDir);
+  const resultsPath = path6.join(tripDir, "results.tsv");
+  const constraintsPath = path6.join(tripDir, "constraints.yaml");
+  const rubricsPath = path6.join(tripDir, "rubrics.yaml");
+  const planPath = path6.join(tripDir, "plan.md");
+  const dbPath = path6.join(tripDir, "activities_db.json");
+  const constraints = yaml5.load(fs7.readFileSync(constraintsPath, "utf-8"));
+  const rubrics = yaml5.load(fs7.readFileSync(rubricsPath, "utf-8"));
+  const scorer = new Scorer(provider);
+  const lastBest = getLastBestScore(resultsPath);
+  let currentScore;
+  let iteration;
+  if (lastBest) {
+    currentScore = lastBest.score;
+    iteration = lastBest.iteration + 1;
+    console.log(`  Resuming from iteration ${iteration} (score: ${currentScore.toFixed(2)})`);
+  } else {
+    console.log("  Scoring baseline...");
+    const planContent = fs7.readFileSync(planPath, "utf-8");
+    const activitiesDb = JSON.parse(fs7.readFileSync(dbPath, "utf-8"));
+    const baselineResult = await scorer.scoreAbsolute(planContent, activitiesDb, constraints, rubrics);
+    currentScore = baselineResult.composite_score;
+    fs7.writeFileSync(path6.join(tripDir, "score.json"), JSON.stringify(baselineResult, null, 2));
+    const log = {
+      iteration: 0,
+      commit: (await git.revparse(["HEAD"])).trim(),
+      score_before: 0,
+      score_after: currentScore,
+      delta: currentScore,
+      status: "keep",
+      mutation_type: "RESEARCH",
+      description: "baseline scored"
+    };
+    appendResult(resultsPath, log);
+    onIteration?.(log);
+    console.log(`  Baseline score: ${currentScore.toFixed(2)}/100`);
+    iteration = 1;
+  }
+  let consecutiveDiscards = 0;
+  console.log("  Starting optimization loop (Ctrl+C to stop)");
+  console.log(`  Score: ${currentScore.toFixed(2)}/100
+`);
+  let running = true;
+  const shutdown = () => {
+    running = false;
+    console.log("\n  Stopping after current iteration...");
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  while (running) {
+    const planContent = fs7.readFileSync(planPath, "utf-8");
+    const activitiesDb = JSON.parse(fs7.readFileSync(dbPath, "utf-8"));
+    const mutationType = pickMutationType(iteration, consecutiveDiscards);
+    try {
+      process.stdout.write(`  [${iteration}] ${mutationType} \u2014 generating mutation...`);
+      const mutation = await generateMutation(
+        provider,
+        mutationType,
+        planContent,
+        constraints,
+        activitiesDb
+      );
+      process.stdout.write("\r\x1B[K");
+      fs7.writeFileSync(planPath, mutation.newPlanContent);
+      await git.add("plan.md");
+      await git.commit(`${mutationType}: ${mutation.description}`);
+      const commitHash = (await git.revparse(["HEAD"])).trim().substring(0, 7);
+      let scoreAfter;
+      let verdict;
+      const isRecalibration = iteration % recalibrationInterval === 0;
+      process.stdout.write(`  [${iteration}] ${mutationType} \u2014 scoring (${isRecalibration ? "absolute" : "comparative"})...`);
+      if (isRecalibration) {
+        const result = await scorer.scoreAbsolute(
+          mutation.newPlanContent,
+          activitiesDb,
+          constraints,
+          rubrics,
+          (msg) => {
+          }
+          // silent logging during loop
+        );
+        scoreAfter = result.composite_score;
+        verdict = scoreAfter > currentScore ? "better" : scoreAfter < currentScore ? "worse" : "neutral";
+        fs7.writeFileSync(path6.join(tripDir, "score.json"), JSON.stringify(result, null, 2));
+      } else {
+        const result = await scorer.scoreComparative(
+          planContent,
+          mutation.newPlanContent,
+          mutation.description,
+          rubrics,
+          (msg) => {
+          }
+          // silent
+        );
+        scoreAfter = currentScore + result.composite_delta;
+        verdict = result.verdict;
+      }
+      process.stdout.write("\r\x1B[K");
+      const delta = scoreAfter - currentScore;
+      const status = verdict === "better" ? "keep" : "discard";
+      if (status === "keep") {
+        currentScore = scoreAfter;
+        consecutiveDiscards = 0;
+      } else {
+        await git.reset(["--hard", "HEAD~1"]);
+        consecutiveDiscards++;
+      }
+      const log = {
+        iteration,
+        commit: commitHash,
+        score_before: currentScore - (status === "keep" ? delta : 0),
+        score_after: scoreAfter,
+        delta,
+        status,
+        mutation_type: mutationType,
+        description: mutation.description
+      };
+      appendResult(resultsPath, log);
+      onIteration?.(log);
+      const statusIcon = status === "keep" ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+      const deltaStr = delta >= 0 ? `\x1B[32m+${delta.toFixed(2)}\x1B[0m` : `\x1B[31m${delta.toFixed(2)}\x1B[0m`;
+      const scoreStr = `\x1B[1m${currentScore.toFixed(2)}\x1B[0m`;
+      console.log(`  [${iteration}] ${statusIcon} ${mutationType.padEnd(10)} ${deltaStr}  ${scoreStr}  ${mutation.description.substring(0, 60)}`);
+    } catch (error) {
+      console.log(`  [${iteration}] ERROR: ${error.message} -- reverting`);
+      try {
+        await git.reset(["--hard", "HEAD"]);
+      } catch {
+      }
+      consecutiveDiscards++;
+    }
+    iteration++;
+  }
+  process.removeListener("SIGINT", shutdown);
+  process.removeListener("SIGTERM", shutdown);
+  console.log(`
+  Stopped at iteration ${iteration - 1}. Best score: ${currentScore.toFixed(2)}/100
+`);
+}
+
+// src/commands/run.ts
+async function runCommand(options) {
+  const cwd = process.cwd();
+  if (!fs8.existsSync(path7.join(cwd, "constraints.yaml"))) {
+    console.log(chalk6.red("\n  Not in a trip project directory (no constraints.yaml found).\n"));
+    process.exit(1);
+  }
+  const config = loadConfig();
+  if (options.standalone) {
+    const provider = createProvider(config);
+    const modelName = config.model_override?.model || process.env.ANTHROPIC_MODEL || "default";
+    console.log(chalk6.bold(`
+  trip-optimizer: standalone mode (${modelName})
+`));
+    await runOptimizationLoop({
+      provider,
+      tripDir: cwd,
+      onIteration: () => {
+      }
+    });
+    return;
+  }
+  if (config.model_override) {
+    console.log(chalk6.yellow("\n  Custom model configured \u2014 agent mode still uses Claude Code."));
+    console.log(chalk6.yellow("  Use --standalone to run with your custom model.\n"));
+  }
+  const { launchAgent } = await import("./commands/run-agent.js");
+  await launchAgent(cwd, { safe: options.safe, headless: options.headless });
+}
+
+// src/commands/status.ts
+import fs9 from "fs";
+import path8 from "path";
+import chalk7 from "chalk";
+import yaml6 from "js-yaml";
+function statusCommand() {
+  const cwd = process.cwd();
+  if (!fs9.existsSync(path8.join(cwd, "constraints.yaml"))) {
+    console.log(chalk7.red("\n  Not in a trip project directory.\n"));
+    process.exit(1);
+  }
+  const constraints = yaml6.load(fs9.readFileSync(path8.join(cwd, "constraints.yaml"), "utf-8"));
+  const resultsPath = path8.join(cwd, "results.tsv");
+  const results = readResults(resultsPath);
+  if (results.length === 0) {
+    console.log(chalk7.yellow("\n  No optimization results yet. Run: trip-optimizer run\n"));
+    return;
+  }
+  const lastBest = getLastBestScore(resultsPath);
+  const baseline = results[0]?.score_after || 0;
+  const totalIterations = results[results.length - 1].iteration;
+  const keeps = results.filter((r) => r.status === "keep").length;
+  const last5 = results.slice(-5);
+  let streak = 0;
+  for (let i = results.length - 1; i >= 0; i--) {
+    if (results[i].status === results[results.length - 1].status) streak++;
+    else break;
+  }
+  const streakType = results[results.length - 1].status;
+  console.log(chalk7.bold(`
+  ${constraints.trip?.name || "Trip"} -- iteration ${totalIterations}
+`));
+  console.log(`  Score: ${chalk7.bold(lastBest?.score.toFixed(2) || "?")}/100  (${baseline > 0 ? `+${(lastBest.score - baseline).toFixed(1)} from baseline` : ""})`);
+  console.log(`  Iterations: ${totalIterations} (${keeps} kept, ${totalIterations - keeps} discarded)`);
+  console.log(`  Streak: ${streak} ${streakType}s in a row`);
+  console.log(chalk7.bold("\n  Last 5 mutations:"));
+  for (const r of last5) {
+    const icon = r.status === "keep" ? chalk7.green("\u2713") : chalk7.red("\u2717");
+    const delta = r.delta >= 0 ? `+${r.delta.toFixed(2)}` : r.delta.toFixed(2);
+    console.log(`    ${icon} ${r.mutation_type.padEnd(10)} ${r.description.substring(0, 50)}  ${delta}`);
+  }
+  const dbPath = path8.join(cwd, "activities_db.json");
+  if (fs9.existsSync(dbPath)) {
+    const db = JSON.parse(fs9.readFileSync(dbPath, "utf-8"));
+    const cities = Object.entries(db);
+    if (cities.length > 0) {
+      console.log(chalk7.bold("\n  Research coverage:"));
+      for (const [city, data] of cities) {
+        const count = (data.activities?.length || 0) + (data.restaurants?.length || 0);
+        const bar = "\u2588".repeat(Math.min(count, 30));
+        console.log(`    ${city.padEnd(15)} ${bar} ${count}`);
+      }
+    }
+  }
+  console.log();
+}
+
+// src/commands/debrief.ts
+import { input as input2, select as select2 } from "@inquirer/prompts";
+import chalk8 from "chalk";
+import ora3 from "ora";
+import fs10 from "fs";
+import path9 from "path";
+
+// src/memory/debrief-processor.ts
+function processDebrief(debrief) {
+  const dayRatings = debrief.day_ratings;
+  const avgRating = dayRatings.length > 0 ? dayRatings.reduce((sum, d) => sum + d.rating, 0) / dayRatings.length : 0;
+  const betterThanExpected = dayRatings.filter((d) => d.surprise === "better").map((d) => d.day);
+  const worseThanExpected = dayRatings.filter((d) => d.surprise === "worse").map((d) => d.day);
+  const rawPatterns = [];
+  if (debrief.skip_next_time.trim()) {
+    rawPatterns.push(
+      ...debrief.skip_next_time.split(",").map((s) => s.trim()).filter(Boolean)
+    );
+  }
+  if (debrief.new_anti_patterns.trim()) {
+    rawPatterns.push(
+      ...debrief.new_anti_patterns.split(",").map((s) => s.trim()).filter(Boolean)
+    );
+  }
+  const newAntiPatterns = [...new Set(rawPatterns)];
+  return {
+    avgRating: Math.round(avgRating * 100) / 100,
+    betterThanExpected,
+    worseThanExpected,
+    newAntiPatterns,
+    highlights: debrief.unexpected_highlights.trim()
+  };
+}
+
+// src/memory/learned-generator.ts
+async function generateLearnedSignals(provider, debriefs) {
+  const debriefSummaries = debriefs.map((d) => ({
+    trip: d.trip_name,
+    date: d.debrief_date,
+    overall_rating: d.overall_rating,
+    day_ratings: d.day_ratings,
+    skip_next_time: d.skip_next_time,
+    highlights: d.unexpected_highlights,
+    anti_patterns: d.new_anti_patterns
+  }));
+  const prompt = `You are a travel preference analyst. Given the following trip debrief data from ${debriefs.length} trip(s), extract patterns about the traveler's preferences.
+
+DEBRIEF DATA:
+${JSON.stringify(debriefSummaries, null, 2)}
+
+Analyze the data and return a JSON object with exactly these fields:
+- "preference_signals": array of strings \u2014 inferred travel preferences (e.g., "prefers walking neighborhoods over bus tours", "enjoys street food over fine dining")
+- "activity_calibration": object mapping activity type strings to rating deltas (e.g., {"museum": -0.5, "street_food": +1.2, "hiking": +0.8}) \u2014 positive means they rated these higher than expected, negative means lower
+- "anti_patterns_learned": array of strings \u2014 things the traveler consistently dislikes or wants to avoid
+- "source_reliability": object mapping source names to reliability scores 0-1 (leave empty {} if no source data)
+
+Return ONLY the JSON object, no other text.`;
+  const response = await provider.complete(prompt, 2e3);
+  const parsed = parseJsonResponse(response);
+  return {
+    preference_signals: parsed.preference_signals ?? [],
+    activity_calibration: parsed.activity_calibration ?? {},
+    anti_patterns_learned: parsed.anti_patterns_learned ?? [],
+    source_reliability: parsed.source_reliability ?? {},
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    trips_analyzed: debriefs.length
+  };
+}
+
+// src/commands/debrief.ts
+function parseDays(planContent) {
+  const dayPattern = /^## Day (\d+)/gm;
+  const days = [];
+  let match;
+  const matches = [];
+  while ((match = dayPattern.exec(planContent)) !== null) {
+    matches.push({ day: parseInt(match[1], 10), index: match.index });
+  }
+  for (let i = 0; i < matches.length; i++) {
+    const start = matches[i].index;
+    const end = i + 1 < matches.length ? matches[i + 1].index : planContent.length;
+    days.push({
+      day: matches[i].day,
+      content: planContent.substring(start, end).trim()
+    });
+  }
+  return days;
+}
+async function debriefCommand() {
+  console.log(chalk8.bold("\n  Post-Trip Debrief\n"));
+  const planPath = path9.resolve("plan.md");
+  if (!fs10.existsSync(planPath)) {
+    console.log(chalk8.red("  No plan.md found in current directory."));
+    console.log(chalk8.dim("  Run this command from a trip project directory.\n"));
+    return;
+  }
+  const planContent = fs10.readFileSync(planPath, "utf-8");
+  const days = parseDays(planContent);
+  if (days.length === 0) {
+    console.log(chalk8.red("  No day sections found in plan.md."));
+    console.log(chalk8.dim('  Expected headers like "## Day 1", "## Day 2", etc.\n'));
+    return;
+  }
+  const tripName = path9.basename(process.cwd());
+  console.log(chalk8.cyan(`  Trip: ${tripName}`));
+  console.log(chalk8.cyan(`  Days found: ${days.length}
+`));
+  const ratingChoices = [
+    { value: 1, name: "1 - Terrible" },
+    { value: 2, name: "2 - Below average" },
+    { value: 3, name: "3 - Average" },
+    { value: 4, name: "4 - Good" },
+    { value: 5, name: "5 - Excellent" }
+  ];
+  const surpriseChoices = [
+    { value: "better", name: "Better than expected" },
+    { value: "expected", name: "As expected" },
+    { value: "worse", name: "Worse than expected" }
+  ];
+  const dayRatings = [];
+  for (const day of days) {
+    console.log(chalk8.bold(`
+  --- Day ${day.day} ---`));
+    const lines = day.content.split("\n");
+    const preview = lines.slice(0, 6).join("\n");
+    console.log(chalk8.dim(preview));
+    console.log("");
+    const rating = await select2({
+      message: `Day ${day.day} rating:`,
+      choices: ratingChoices
+    });
+    const surprise = await select2({
+      message: `Day ${day.day} surprise level:`,
+      choices: surpriseChoices
+    });
+    const notes = await input2({
+      message: `Day ${day.day} notes (optional):`,
+      default: ""
+    });
+    dayRatings.push({
+      day: day.day,
+      rating,
+      surprise,
+      notes
+    });
+  }
+  console.log(chalk8.bold("\n  --- Overall Trip ---\n"));
+  const overallRating = await select2({
+    message: "Overall trip rating:",
+    choices: ratingChoices
+  });
+  const skipNextTime = await input2({
+    message: "What would you skip next time? (comma-separated)",
+    default: ""
+  });
+  const highlights = await input2({
+    message: "What unexpected highlights?",
+    default: ""
+  });
+  const newAntiPatterns = await input2({
+    message: "Any new anti-patterns discovered? (comma-separated)",
+    default: ""
+  });
+  const debrief = {
+    trip_name: tripName,
+    trip_dir: process.cwd(),
+    debrief_date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    overall_rating: overallRating,
+    day_ratings: dayRatings,
+    skip_next_time: skipNextTime,
+    unexpected_highlights: highlights,
+    new_anti_patterns: newAntiPatterns
+  };
+  const globalDir = getGlobalDir();
+  fs10.mkdirSync(globalDir, { recursive: true });
+  const historyPath = getTripHistoryPath();
+  let history = [];
+  if (fs10.existsSync(historyPath)) {
+    history = JSON.parse(fs10.readFileSync(historyPath, "utf-8"));
+  }
+  history.push(debrief);
+  fs10.writeFileSync(historyPath, JSON.stringify(history, null, 2));
+  console.log(chalk8.green("\n  Debrief saved to trip history."));
+  const processed = processDebrief(debrief);
+  console.log(chalk8.dim(`  Average day rating: ${processed.avgRating}`));
+  if (processed.betterThanExpected.length > 0) {
+    console.log(chalk8.dim(`  Better than expected: Days ${processed.betterThanExpected.join(", ")}`));
+  }
+  if (processed.worseThanExpected.length > 0) {
+    console.log(chalk8.dim(`  Worse than expected: Days ${processed.worseThanExpected.join(", ")}`));
+  }
+  const config = loadConfig();
+  const hasProvider = config.api_key || process.env.CLAUDE_CODE_USE_VERTEX === "1" || process.env.GOOGLE_CLOUD_PROJECT;
+  if (hasProvider) {
+    const spinner = ora3("Generating learned preferences from debrief history...").start();
+    try {
+      const provider = createProvider(config);
+      const learned = await generateLearnedSignals(provider, history);
+      const learnedPath = getLearnedPath();
+      fs10.writeFileSync(learnedPath, JSON.stringify(learned, null, 2));
+      spinner.succeed("Learned preferences updated");
+      const profile = loadProfile();
+      if (learned.preference_signals.length > 0) {
+        profile.learned_vibes = learned.preference_signals;
+      }
+      if (learned.anti_patterns_learned.length > 0) {
+        profile.anti_patterns_learned = learned.anti_patterns_learned;
+      }
+      if (Object.keys(learned.source_reliability).length > 0) {
+        profile.source_trust = learned.source_reliability;
+      }
+      profile.trips_completed = history.length;
+      profile.last_debrief = debrief.debrief_date;
+      saveProfile(profile);
+      console.log(chalk8.green("  Profile updated with learned preferences.\n"));
+    } catch (err) {
+      spinner.fail("Could not generate learned preferences (LLM error)");
+      console.log(chalk8.dim(`  ${err instanceof Error ? err.message : String(err)}
+`));
+      const profile = loadProfile();
+      profile.trips_completed = history.length;
+      profile.last_debrief = debrief.debrief_date;
+      saveProfile(profile);
+    }
+  } else {
+    console.log(chalk8.yellow("  No API key configured \u2014 skipping learned preferences generation."));
+    console.log(chalk8.dim('  Run "trip-optimizer config set api_key <key>" to enable.\n'));
+    const profile = loadProfile();
+    profile.trips_completed = history.length;
+    profile.last_debrief = debrief.debrief_date;
+    saveProfile(profile);
+  }
+}
+
+// src/commands/history.ts
+import chalk9 from "chalk";
+import fs11 from "fs";
+async function historyCommand() {
+  const historyPath = getTripHistoryPath();
+  if (!fs11.existsSync(historyPath)) {
+    console.log(chalk9.yellow("\n  No trip history found."));
+    console.log(chalk9.dim('  Complete a trip and run "trip-optimizer debrief" to build history.\n'));
+    return;
+  }
+  const history = JSON.parse(fs11.readFileSync(historyPath, "utf-8"));
+  if (history.length === 0) {
+    console.log(chalk9.yellow("\n  No trip debriefs recorded yet.\n"));
+    return;
+  }
+  console.log(chalk9.bold("\n  Trip History\n"));
+  const nameWidth = 30;
+  const dateWidth = 12;
+  const ratingWidth = 8;
+  const daysWidth = 6;
+  const header = "  " + "Trip".padEnd(nameWidth) + "Date".padEnd(dateWidth) + "Rating".padEnd(ratingWidth) + "Days".padEnd(daysWidth);
+  console.log(chalk9.dim(header));
+  console.log(chalk9.dim("  " + "-".repeat(nameWidth + dateWidth + ratingWidth + daysWidth)));
+  for (const trip of history) {
+    const stars = "\u2605".repeat(trip.overall_rating) + "\u2606".repeat(5 - trip.overall_rating);
+    const name = trip.trip_name.length > nameWidth - 2 ? trip.trip_name.substring(0, nameWidth - 5) + "..." : trip.trip_name;
+    const line = "  " + name.padEnd(nameWidth) + trip.debrief_date.padEnd(dateWidth) + stars.padEnd(ratingWidth) + String(trip.day_ratings.length).padEnd(daysWidth);
+    console.log(line);
+  }
+  console.log("");
+  const avgRating = history.reduce((s, t2) => s + t2.overall_rating, 0) / history.length;
+  console.log(chalk9.dim(`  ${history.length} trip(s) | Average rating: ${avgRating.toFixed(1)}/5
+`));
+}
+
+// src/commands/dashboard.ts
+import fs12 from "fs";
+import path10 from "path";
+import chalk10 from "chalk";
+import yaml7 from "js-yaml";
+function progressBar(value, max, width = 30) {
+  const filled = Math.round(value / max * width);
+  const empty = width - filled;
+  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+  return `[${bar}]`;
+}
+function trendArrow(current, previous) {
+  const diff = current - previous;
+  if (diff > 0.5) return chalk10.green("\u2191");
+  if (diff < -0.5) return chalk10.red("\u2193");
+  return chalk10.gray("\u2192");
+}
+function renderDashboard() {
+  const cwd = process.cwd();
+  if (!fs12.existsSync(path10.join(cwd, "constraints.yaml"))) {
+    console.log(chalk10.red("\n  Not in a trip project directory.\n"));
+    process.exit(1);
+  }
+  const constraints = yaml7.load(
+    fs12.readFileSync(path10.join(cwd, "constraints.yaml"), "utf-8")
+  );
+  const resultsPath = path10.join(cwd, "results.tsv");
+  const results = readResults(resultsPath);
+  console.log(chalk10.bold.cyan(`
+  === ${constraints.trip?.name || "Trip Optimizer"} Dashboard ===
+`));
+  if (results.length === 0) {
+    console.log(chalk10.yellow("  No optimization results yet. Run: trip-optimizer run\n"));
+    return;
+  }
+  const lastBest = getLastBestScore(resultsPath);
+  const score = lastBest?.score ?? 0;
+  console.log(`  Score: ${progressBar(score, 100)} ${chalk10.bold(score.toFixed(2))}/100`);
+  const scorePath = path10.join(cwd, "score.json");
+  if (fs12.existsSync(scorePath)) {
+    try {
+      const scoreData = JSON.parse(fs12.readFileSync(scorePath, "utf-8"));
+      if (scoreData.components) {
+        console.log(chalk10.bold("\n  Dimensions:"));
+        const keeps2 = results.filter((r) => r.status === "keep");
+        const prevScore = keeps2.length >= 2 ? keeps2[keeps2.length - 2].score_after : score;
+        for (const [dim, result] of Object.entries(scoreData.components)) {
+          const dimScore = result.score;
+          const arrow = trendArrow(dimScore, prevScore > 0 ? dimScore : dimScore);
+          const bar = progressBar(dimScore, 100, 15);
+          const penalty = result.penalty ? chalk10.red(` (-${result.penalty})`) : "";
+          console.log(`    ${dim.padEnd(18)} ${bar} ${dimScore.toFixed(1)}${penalty} ${arrow}`);
+        }
+        if (scoreData.penalties && scoreData.penalties.length > 0) {
+          console.log(chalk10.bold.red(`
+  Penalties: ${scoreData.penalties.length} remaining`));
+          for (const p of scoreData.penalties.slice(0, 5)) {
+            console.log(chalk10.red(`    -${p.penalty}  Day ${p.day}: ${p.issue.substring(0, 60)}`));
+          }
+          if (scoreData.penalties.length > 5) {
+            console.log(chalk10.gray(`    ... and ${scoreData.penalties.length - 5} more`));
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const last5 = results.slice(-5);
+  console.log(chalk10.bold("\n  Recent Mutations:"));
+  for (const r of last5) {
+    const icon = r.status === "keep" ? chalk10.green("\u2713") : chalk10.red("\u2717");
+    const delta = r.delta >= 0 ? chalk10.green(`+${r.delta.toFixed(2)}`) : chalk10.red(r.delta.toFixed(2));
+    console.log(`    ${icon} #${String(r.iteration).padStart(3)} ${r.mutation_type.padEnd(10)} ${r.description.substring(0, 45).padEnd(45)} ${delta}`);
+  }
+  const totalIterations = results[results.length - 1].iteration;
+  const keeps = results.filter((r) => r.status === "keep").length;
+  const keepRate = (keeps / results.length * 100).toFixed(1);
+  const baseline = results[0]?.score_after || 0;
+  const totalDelta = score - baseline;
+  console.log(chalk10.bold("\n  Stats:"));
+  console.log(`    Iterations:  ${totalIterations}`);
+  console.log(`    Keep rate:   ${keepRate}% (${keeps}/${results.length})`);
+  console.log(`    Baseline:    ${baseline.toFixed(2)}`);
+  console.log(`    Total delta: ${totalDelta >= 0 ? chalk10.green(`+${totalDelta.toFixed(2)}`) : chalk10.red(totalDelta.toFixed(2))}`);
+  const dbPath = path10.join(cwd, "activities_db.json");
+  if (fs12.existsSync(dbPath)) {
+    try {
+      const db = JSON.parse(fs12.readFileSync(dbPath, "utf-8"));
+      const cities = Object.entries(db);
+      if (cities.length > 0) {
+        console.log(chalk10.bold("\n  Research Coverage:"));
+        for (const [city, data] of cities) {
+          const activities = data.activities?.length || 0;
+          const restaurants = data.restaurants?.length || 0;
+          const total = activities + restaurants;
+          const bar = progressBar(Math.min(total, 50), 50, 15);
+          console.log(`    ${city.padEnd(15)} ${bar} ${chalk10.cyan(`${activities}a`)} ${chalk10.yellow(`${restaurants}r`)}`);
+        }
+      }
+    } catch {
+    }
+  }
+  console.log();
+}
+function dashboardCommand(options) {
+  if (options.watch) {
+    const render = () => {
+      process.stdout.write("\x1B[2J\x1B[0f");
+      renderDashboard();
+      console.log(chalk10.gray("  Auto-refreshing every 5s. Press Ctrl+C to stop."));
+    };
+    render();
+    setInterval(render, 5e3);
+  } else {
+    renderDashboard();
+  }
+}
+
+// src/commands/chart.ts
+import path11 from "path";
+import chalk11 from "chalk";
+import asciichart from "asciichart";
+function chartCommand() {
+  const cwd = process.cwd();
+  const resultsPath = path11.join(cwd, "results.tsv");
+  const results = readResults(resultsPath);
+  if (results.length === 0) {
+    console.log(chalk11.yellow("\n  No optimization results yet. Run: trip-optimizer run\n"));
+    return;
+  }
+  const scores = [];
+  let currentBest = results[0].score_before;
+  scores.push(currentBest);
+  for (const r of results) {
+    if (r.status === "keep") {
+      currentBest = r.score_after;
+    }
+    scores.push(currentBest);
+  }
+  console.log(chalk11.bold.cyan("\n  Score Progression"));
+  console.log(chalk11.gray(`  ${results.length} iterations, ${results.filter((r) => r.status === "keep").length} kept
+`));
+  const width = Math.min(process.stdout.columns || 80, 120) - 15;
+  const chartHeight = 15;
+  let plotData = scores;
+  if (scores.length > width) {
+    const step = scores.length / width;
+    plotData = [];
+    for (let i = 0; i < width; i++) {
+      plotData.push(scores[Math.floor(i * step)]);
+    }
+  }
+  const chart = asciichart.plot(plotData, {
+    height: chartHeight,
+    format: (x) => x.toFixed(1).padStart(6)
+  });
+  console.log(chart);
+  const first = scores[0];
+  const last = scores[scores.length - 1];
+  const max = Math.max(...scores);
+  const min = Math.min(...scores);
+  console.log();
+  console.log(`  Start: ${chalk11.gray(first.toFixed(2))}  Current: ${chalk11.bold(last.toFixed(2))}  Peak: ${chalk11.green(max.toFixed(2))}  Low: ${chalk11.red(min.toFixed(2))}`);
+  console.log();
+}
+
+// src/commands/plan.ts
+import fs13 from "fs";
+import path12 from "path";
+import chalk12 from "chalk";
+import PDFDocument from "pdfkit";
+import yaml8 from "js-yaml";
+function planCommand(options = {}) {
+  const cwd = process.cwd();
+  const planPath = path12.join(cwd, "plan.md");
+  if (!fs13.existsSync(planPath)) {
+    console.log(chalk12.red("\n  No plan.md found in current directory.\n"));
+    process.exit(1);
+  }
+  const content = fs13.readFileSync(planPath, "utf-8");
+  if (options.pdf) {
+    const outputPath = options.output || path12.join(cwd, "plan.pdf");
+    generatePdf(content, outputPath);
+    console.log(chalk12.green(`
+  PDF saved to ${outputPath}
+`));
+    return;
+  }
+  const lines = content.split("\n");
+  console.log();
+  for (const line of lines) {
+    console.log(formatLine(line));
+  }
+  console.log();
+}
+var MARGIN = 54;
+var PAGE_W = 612;
+var PAGE_H = 792;
+var CONTENT_W = PAGE_W - MARGIN * 2;
+var PAGE_BOTTOM = PAGE_H - MARGIN - 20;
+function parseFrontmatter(markdown) {
+  if (markdown.startsWith("---")) {
+    const end = markdown.indexOf("---", 3);
+    if (end !== -1) {
+      const fmText = markdown.slice(3, end).trim();
+      const fm = yaml8.load(fmText);
+      return { frontmatter: fm, body: markdown.slice(end + 3).trimStart() };
+    }
+  }
+  return { frontmatter: {}, body: markdown };
+}
+function stripEmoji(text) {
+  return text.replace(/[\u{1F600}-\u{1F9FF}\u{1F300}-\u{1F5FF}\u{1F680}-\u{1F6FF}\u{FE00}-\u{FE0F}\u{1FA00}-\u{1FAFF}\u{200D}\u{20E3}\u{E0020}-\u{E007F}]/gu, "").replace(/\u2192/g, " -- ").replace(/[\u25C6\u2764\u2B50\u2728\u26A0\u2705\u274C\u{1F3D4}]/gu, "").trim();
+}
+function ensureSpace(doc, needed) {
+  if (doc.y + needed > PAGE_BOTTOM) {
+    doc.addPage();
+  }
+}
+function generatePdf(markdown, outputPath) {
+  const { frontmatter, body } = parseFrontmatter(markdown);
+  const doc = new PDFDocument({
+    size: "LETTER",
+    margins: { top: MARGIN, bottom: MARGIN, left: MARGIN, right: MARGIN }
+  });
+  const stream = fs13.createWriteStream(outputPath);
+  doc.pipe(stream);
+  renderCoverPage(doc, frontmatter);
+  const lines = body.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed) {
+      doc.moveDown(0.25);
+      i++;
+      continue;
+    }
+    if (/^---+$/.test(trimmed)) {
+      doc.moveDown(0.3);
+      i++;
+      continue;
+    }
+    if (/^#{1,2}\s+Day\s+\d+/i.test(trimmed)) {
+      doc.addPage();
+      const headerText = stripEmoji(trimmed.replace(/^#{1,2}\s+/, ""));
+      doc.font("Helvetica-Bold").fontSize(18).fillColor("#1a1a2e").text(headerText, MARGIN, MARGIN, { width: CONTENT_W });
+      const y = doc.y + 2;
+      doc.moveTo(MARGIN, y).lineTo(MARGIN + CONTENT_W, y).strokeColor("#0984e3").lineWidth(1.5).stroke();
+      doc.lineWidth(1);
+      doc.moveDown(0.4);
+      i++;
+      if (i < lines.length && /^\s*\*[^*]+\*\s*$/.test(lines[i].trim())) {
+        const theme = lines[i].trim().replace(/^\*|\*$/g, "");
+        doc.font("Helvetica-Oblique").fontSize(10).fillColor("#636e72").text(theme, MARGIN, void 0, { width: CONTENT_W });
+        doc.moveDown(0.5);
+        i++;
+      }
+      continue;
+    }
+    if (/^# [^#]/.test(trimmed)) {
+      ensureSpace(doc, 40);
+      doc.moveDown(0.5);
+      const title = stripEmoji(trimmed.replace(/^# /, ""));
+      doc.font("Helvetica-Bold").fontSize(16).fillColor("#1a1a2e").text(title, MARGIN, void 0, { width: CONTENT_W });
+      const y = doc.y + 1;
+      doc.moveTo(MARGIN, y).lineTo(MARGIN + CONTENT_W, y).strokeColor("#cccccc").lineWidth(0.5).stroke();
+      doc.lineWidth(1);
+      doc.moveDown(0.4);
+      i++;
+      continue;
+    }
+    if (/^#{2,3}\s+/.test(trimmed)) {
+      ensureSpace(doc, 30);
+      doc.moveDown(0.4);
+      const heading = stripEmoji(trimmed.replace(/^#{2,3}\s+/, ""));
+      doc.font("Helvetica-Bold").fontSize(12).fillColor("#2d3436").text(heading, MARGIN, void 0, { width: CONTENT_W });
+      doc.moveDown(0.2);
+      i++;
+      continue;
+    }
+    if (trimmed.startsWith("|")) {
+      i = renderTable(doc, lines, i);
+      continue;
+    }
+    if (/^\*[^*]+\*$/.test(trimmed)) {
+      ensureSpace(doc, 16);
+      const text = stripEmoji(trimmed.replace(/^\*|\*$/g, ""));
+      doc.font("Helvetica-Oblique").fontSize(10).fillColor("#636e72").text(text, MARGIN, void 0, { width: CONTENT_W });
+      doc.moveDown(0.2);
+      i++;
+      continue;
+    }
+    if (/^\*\*(?:Hotel|Transit|Reality check)[:.]/.test(trimmed)) {
+      ensureSpace(doc, 20);
+      doc.moveDown(0.15);
+      renderRichText(doc, stripEmoji(trimmed), MARGIN, CONTENT_W, 9.5, "#555555");
+      doc.moveDown(0.15);
+      i++;
+      continue;
+    }
+    if (/^\s{2,}[-*]\s+/.test(line)) {
+      ensureSpace(doc, 16);
+      const text = stripEmoji(trimmed.replace(/^[-*]\s+/, ""));
+      renderBullet(doc, text, 80, CONTENT_W - 26, "-");
+      i++;
+      continue;
+    }
+    if (/^[-*]\s+/.test(trimmed)) {
+      ensureSpace(doc, 16);
+      const text = stripEmoji(trimmed.replace(/^[-*]\s+/, ""));
+      renderBullet(doc, text, MARGIN + 8, CONTENT_W - 8, "\u2022");
+      i++;
+      continue;
+    }
+    ensureSpace(doc, 16);
+    renderRichText(doc, stripEmoji(trimmed), MARGIN, CONTENT_W, 10, "#333333");
+    doc.moveDown(0.15);
+    i++;
+  }
+  doc.end();
+}
+function renderCoverPage(doc, fm) {
+  const centerX = PAGE_W / 2;
+  const name = (fm.trip_name || "Travel Plan").toUpperCase();
+  doc.font("Helvetica-Bold").fontSize(32).fillColor("#1a1a2e");
+  doc.text(name, MARGIN, 220, { width: CONTENT_W, align: "center" });
+  doc.moveDown(0.5);
+  const lineY = doc.y;
+  const lineW = 200;
+  doc.moveTo(centerX - lineW / 2, lineY).lineTo(centerX + lineW / 2, lineY).strokeColor("#0984e3").lineWidth(2).stroke();
+  doc.lineWidth(1);
+  doc.moveDown(1);
+  doc.font("Helvetica").fontSize(13).fillColor("#555555");
+  const details = [];
+  if (fm.start_date && fm.end_date) {
+    const fmtDate = (d) => {
+      const date = d instanceof Date ? d : new Date(d);
+      return date.toLocaleDateString("en-US", { month: "long", day: "numeric", year: "numeric", timeZone: "UTC" });
+    };
+    details.push(`${fmtDate(fm.start_date)} to ${fmtDate(fm.end_date)}`);
+  }
+  if (fm.total_days) {
+    details.push(`${fm.total_days} days`);
+  }
+  if (fm.origin) {
+    details.push(`From ${fm.origin}`);
+  }
+  if (fm.total_budget && fm.currency) {
+    details.push(`Budget: ${fm.currency} ${fm.total_budget.toLocaleString()}`);
+  } else if (fm.total_budget) {
+    details.push(`Budget: $${fm.total_budget.toLocaleString()}`);
+  }
+  if (fm.travelers) {
+    details.push(`${fm.travelers} traveler${fm.travelers > 1 ? "s" : ""}`);
+  }
+  for (const detail of details) {
+    doc.text(detail, MARGIN, void 0, { width: CONTENT_W, align: "center" });
+    doc.moveDown(0.3);
+  }
+  doc.font("Helvetica-Oblique").fontSize(9).fillColor("#999999");
+  doc.text("Generated by trip-optimizer", MARGIN, PAGE_H - MARGIN - 30, {
+    width: CONTENT_W,
+    align: "center"
+  });
+  doc.addPage();
+}
+function renderTable(doc, lines, startIdx) {
+  const rows = [];
+  let i = startIdx;
+  while (i < lines.length && lines[i].trim().startsWith("|")) {
+    const row = lines[i].trim();
+    if (/^\|[\s-:|]+\|$/.test(row)) {
+      i++;
+      continue;
+    }
+    const cells = row.split("|").filter((_, idx, arr) => idx > 0 && idx < arr.length - 1).map((c) => stripEmoji(c.trim().replace(/\*\*/g, "")));
+    rows.push(cells);
+    i++;
+  }
+  if (rows.length === 0) return i;
+  const colCount = rows[0].length;
+  const col1Width = CONTENT_W * 0.62;
+  const col2Width = CONTENT_W * 0.38;
+  const colWidths = colCount === 2 ? [col1Width, col2Width] : Array(colCount).fill(CONTENT_W / colCount);
+  const rowHeight = 20;
+  ensureSpace(doc, Math.min(rows.length + 1, 6) * rowHeight);
+  const startX = MARGIN;
+  let y = doc.y;
+  if (rows.length > 0) {
+    doc.rect(startX, y, CONTENT_W, rowHeight).fill("#e8e8e8");
+    doc.font("Helvetica-Bold").fontSize(9).fillColor("#2d3436");
+    let x = startX;
+    for (let c = 0; c < rows[0].length && c < colWidths.length; c++) {
+      doc.text(rows[0][c], x + 5, y + 5, { width: colWidths[c] - 10, lineBreak: false });
+      x += colWidths[c];
+    }
+    y += rowHeight;
+    doc.moveTo(startX, y).lineTo(startX + CONTENT_W, y).strokeColor("#0984e3").lineWidth(1).stroke();
+  }
+  for (let r = 1; r < rows.length; r++) {
+    if (y + rowHeight > PAGE_BOTTOM) {
+      doc.addPage();
+      y = MARGIN;
+    }
+    if (r % 2 === 0) {
+      doc.rect(startX, y, CONTENT_W, rowHeight).fill("#f5f5f5");
+    }
+    const isTotalRow = rows[r][0]?.toLowerCase().includes("total");
+    doc.font(isTotalRow ? "Helvetica-Bold" : "Helvetica").fontSize(9).fillColor("#333333");
+    let x = startX;
+    for (let c = 0; c < rows[r].length && c < colWidths.length; c++) {
+      doc.text(rows[r][c], x + 5, y + 5, { width: colWidths[c] - 10, lineBreak: false });
+      x += colWidths[c];
+    }
+    y += rowHeight;
+  }
+  doc.moveTo(startX, y).lineTo(startX + CONTENT_W, y).strokeColor("#cccccc").lineWidth(0.5).stroke();
+  doc.lineWidth(1);
+  doc.y = y + 8;
+  return i;
+}
+function renderBullet(doc, text, x, width, bulletChar) {
+  const bulletX = x - 10;
+  const y = doc.y;
+  doc.font("Helvetica").fontSize(10).fillColor("#333333").text(bulletChar, bulletX, y, { width: 10, continued: false });
+  doc.y = y;
+  renderRichText(doc, text, x, width, 10, "#333333");
+  doc.moveDown(0.1);
+}
+function renderRichText(doc, text, x, width, fontSize, defaultColor) {
+  const segments = [];
+  const pattern = /(\*\*[^*]+\*\*|\*[^*]+\*)/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      segments.push({ text: text.slice(lastIndex, match.index), bold: false, italic: false });
+    }
+    const m = match[0];
+    if (m.startsWith("**")) {
+      segments.push({ text: m.slice(2, -2), bold: true, italic: false });
+    } else {
+      segments.push({ text: m.slice(1, -1), bold: false, italic: true });
+    }
+    lastIndex = match.index + m.length;
+  }
+  if (lastIndex < text.length) {
+    segments.push({ text: text.slice(lastIndex), bold: false, italic: false });
+  }
+  if (segments.length === 0) return;
+  if (segments.length === 1 && !segments[0].bold && !segments[0].italic) {
+    doc.font("Helvetica").fontSize(fontSize).fillColor(defaultColor).text(segments[0].text, x, doc.y, { width, lineBreak: true });
+    return;
+  }
+  const startY = doc.y;
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const isLast = i === segments.length - 1;
+    if (seg.bold) {
+      doc.font("Helvetica-Bold").fontSize(fontSize).fillColor("#2d3436");
+    } else if (seg.italic) {
+      doc.font("Helvetica-Oblique").fontSize(fontSize).fillColor("#636e72");
+    } else {
+      doc.font("Helvetica").fontSize(fontSize).fillColor(defaultColor);
+    }
+    if (i === 0) {
+      doc.text(seg.text, x, startY, { width, continued: !isLast });
+    } else {
+      doc.text(seg.text, { continued: !isLast });
+    }
+  }
+}
+function formatLine(line) {
+  if (/^#{1,3}\s+Day\s+\d+/i.test(line)) {
+    return chalk12.bold.magenta(line);
+  }
+  if (/^#{1,2}\s+/.test(line)) {
+    return chalk12.bold.cyan(line);
+  }
+  if (/^#{3,}\s+/.test(line)) {
+    return chalk12.bold(line);
+  }
+  let formatted = line.replace(
+    /\b(\d{1,2}:\d{2}(\s*[AaPp][Mm])?)\b/g,
+    (match) => chalk12.bold(match)
+  );
+  formatted = formatted.replace(
+    /(?:restaurant|cafe|bakery|noodle|dumpling|hotpot|teahouse|bistro|eatery|diner|food stall|street food)/gi,
+    (match) => chalk12.yellow(match)
+  );
+  formatted = formatted.replace(
+    /(?:Lunch|Dinner|Breakfast|Brunch|Snack):\s*(.+?)(?:\s*[-\u2013\u2014(]|$)/gi,
+    (match, name) => match.replace(name, chalk12.yellow(name))
+  );
+  formatted = formatted.replace(
+    /\*\*([^*]+)\*\*/g,
+    (_match, name) => chalk12.cyan.bold(name)
+  );
+  formatted = formatted.replace(
+    /(?:hotel|hostel|guesthouse|airbnb|accommodation|check[- ]?in|check[- ]?out|Le\s+M[eé]ridien|Sheraton|Courtyard|Marriott)/gi,
+    (match) => chalk12.blue(match)
+  );
+  formatted = formatted.replace(
+    /[¥$€£]\s?\d[\d,.]*/g,
+    (match) => chalk12.green(match)
+  );
+  return formatted;
+}
+
+// src/cli.ts
+var _cfg = loadConfig();
+if (_cfg.language) setLanguage(_cfg.language);
+var program = new Command();
+program.name("trip-optimizer").description("Autonomously optimize travel plans using the autoresearch pattern").version("0.1.0");
+program.command("init <name>").description("Create a new trip project").action(initCommand);
+program.command("config").description("Manage API keys and provider settings").argument("[args...]", "config subcommand and arguments").action((args) => configCommand(args));
+program.command("profile").description("View travel profile and preferences").action(() => profileCommand());
+program.command("score").description("Run a one-off absolute score of the current plan").action(scoreCommand);
+program.command("research [city]").description("Research sprint for a specific city or all cities").action(researchCommand);
+program.command("run").description("Start the optimization loop (default: agent mode)").option("--standalone", "Use direct API calls instead of Claude Code agent").option("--headless", "Run agent non-interactively (fire and forget)").option("--safe", "Use normal permissions in agent mode (no yolo)").action(runCommand);
+program.command("status").description("Show current score and optimization progress").action(statusCommand);
+program.command("debrief").description("Post-trip debrief \u2014 rate experiences and build memory").action(debriefCommand);
+program.command("history").description("View past trip debriefs and learned preferences").action(historyCommand);
+program.command("dashboard").description("Live dashboard showing optimization progress").option("--watch", "Auto-refresh every 5 seconds").action((options) => dashboardCommand(options));
+program.command("chart").description("ASCII chart of score progression").action(chartCommand);
+program.command("plan").description("Pretty-print the current travel plan").option("--pdf", "Generate a PDF document").option("-o, --output <path>", "Output path for PDF").action(planCommand);
+process.on("unhandledRejection", (err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  console.error(`
+  \x1B[31mError: ${msg}\x1B[0m`);
+  if (msg.includes("401") || msg.includes("403") || msg.includes("Authentication") || msg.includes("PERMISSION")) {
+    if (_cfg.model_override) {
+      console.error(`  \x1B[33mAPI key for ${_cfg.model_override.model} is invalid or expired.\x1B[0m`);
+    } else if (process.env.CLAUDE_CODE_USE_VERTEX === "1" || process.env.GOOGLE_CLOUD_PROJECT) {
+      console.error("  \x1B[33mAuthentication failed. Run: gcloud auth application-default login\x1B[0m");
+    } else {
+      console.error("  \x1B[33mAnthropic API key is invalid. Run: trip-optimizer config set api_key <key>\x1B[0m");
+    }
+  } else if (msg.includes("404") || msg.includes("NOT_FOUND")) {
+    if (_cfg.model_override) {
+      console.error(`  \x1B[33mModel "${_cfg.model_override.model}" not found at ${_cfg.model_override.base_url}\x1B[0m`);
+    } else {
+      console.error(`  \x1B[33mModel not found. Check ANTHROPIC_MODEL=${process.env.ANTHROPIC_MODEL || "(not set)"}\x1B[0m`);
+    }
+  } else if (msg.includes("ENOTFOUND") || msg.includes("ECONNREFUSED")) {
+    console.error("  \x1B[33mNetwork error. Check your internet connection.\x1B[0m");
+  }
+  console.error();
+  process.exit(1);
+});
+program.parse();