tripkit 1.1.0 → 1.4.0

package/scripts/test-media-lifecycle.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+/**
+ * End-to-end regression test for the post-trip media flow.
+ *
+ * Exercises the full lifecycle on a freshly-authored trip:
+ *   author trip -> validate -> render (pre)        [no media]
+ *   -> generate geotagged fixtures
+ *   -> `tripkit media` (build review)              [EXIF match + buckets]
+ *   -> review/caption + promote an unmatched item  [simulates the human/AI step]
+ *   -> `tripkit media apply`                        [merge into stops[].media[]]
+ *   -> re-apply                                     [idempotency]
+ *   -> validate (errors vs warnings) -> render (post)
+ *   -> assert the rendered HTML embeds the media + captions.
+ *
+ * Self-contained: builds fixtures in an OS temp dir and cleans up. `sharp` is
+ * optional — thumbnail assertions soft-pass (with a note) when it isn't installed,
+ * so this can run in `npm test` on a sharp-free CI.
+ *
+ * Run: node scripts/test-media-lifecycle.js   (also wired into `npm test`)
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const CONVERT = path.join(ROOT, 'convert.js');
+const yaml = require(path.join(ROOT, 'node_modules', 'js-yaml'));
+const { validate } = require(path.join(ROOT, 'validate'));
+
+let sharp = null;
+try { sharp = require(path.join(ROOT, 'node_modules', 'sharp')); } catch (_) { /* optional */ }
+const HAVE_SHARP = !!sharp;
+
+let failures = 0;
+function check(name, cond, detail) {
+  const ok = !!cond;
+  console.log(`  ${ok ? '✓' : '✗'} ${name}${ok ? '' : `  — ${detail || ''}`}`);
+  if (!ok) failures++;
+}
+function soft(name, cond, detail) {
+  if (!HAVE_SHARP) { console.log(`  ⊘ ${name} (skipped — sharp not installed)`); return; }
+  check(name, cond, detail);
+}
+function tk(args) {
+  return execFileSync('node', [CONVERT, ...args], { env: { ...process.env, NO_COLOR: '1' }, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+}
+
+// --- Minimal JPEG with GPS + DateTimeOriginal EXIF (no external EXIF writer needed) ---
+function buildExif({ lat, lng, dateStr }) {
+  const tiff = Buffer.alloc(8192);
+  let p = 0;
+  const u16 = (v) => { tiff.writeUInt16LE(v, p); p += 2; };
+  const u32 = (v) => { tiff.writeUInt32LE(v, p); p += 4; };
+  tiff.write('II', p); p += 2; tiff.writeUInt16LE(42, p); p += 2; tiff.writeUInt32LE(8, p); p += 4;
+  const dt = Buffer.from(dateStr + '\0', 'ascii');
+  const dms = (dec) => { const d = Math.floor(Math.abs(dec)); const mf = (Math.abs(dec) - d) * 60; const m = Math.floor(mf); const s = (mf - m) * 60; return [[d, 1], [m, 1], [Math.round(s * 100), 100]]; };
+  const rationals = (arr) => { const b = Buffer.alloc(arr.length * 8); arr.forEach((pr, i) => { b.writeUInt32LE(pr[0], i * 8); b.writeUInt32LE(pr[1], i * 8 + 4); }); return b; };
+  const latBuf = rationals(dms(lat)), lngBuf = rationals(dms(lng));
+  const latRef = (lat >= 0 ? 'N' : 'S'), lngRef = (lng >= 0 ? 'E' : 'W');
+  const IFD0_OFF = 8, IFD0_SIZE = 2 + 2 * 12 + 4;
+  const EXIF_OFF = IFD0_OFF + IFD0_SIZE, EXIF_SIZE = 2 + 1 * 12 + 4;
+  const GPS_OFF = EXIF_OFF + EXIF_SIZE, GPS_SIZE = 2 + 4 * 12 + 4;
+  const DATA_OFF = GPS_OFF + GPS_SIZE;
+  const dtOff = DATA_OFF, latOff = dtOff + dt.length, lngOff = latOff + latBuf.length;
+  p = IFD0_OFF; u16(2);
+  u16(0x8769); u16(4); u32(1); u32(EXIF_OFF);
+  u16(0x8825); u16(4); u32(1); u32(GPS_OFF); u32(0);
+  p = EXIF_OFF; u16(1); u16(0x9003); u16(2); u32(dt.length); u32(dtOff); u32(0);
+  p = GPS_OFF; u16(4);
+  u16(0x0001); u16(2); u32(2); { const sp = p; tiff.write(latRef, p, 'ascii'); p = sp + 4; }
+  u16(0x0002); u16(5); u32(3); u32(latOff);
+  u16(0x0003); u16(2); u32(2); { const sp = p; tiff.write(lngRef, p, 'ascii'); p = sp + 4; }
+  u16(0x0004); u16(5); u32(3); u32(lngOff); u32(0);
+  dt.copy(tiff, dtOff); latBuf.copy(tiff, latOff); lngBuf.copy(tiff, lngOff);
+  return Buffer.concat([Buffer.from('Exif\0\0', 'ascii'), tiff.subarray(0, lngOff + lngBuf.length)]);
+}
+// A tiny valid baseline JPEG (1x1) we can append EXIF to — avoids needing sharp to make fixtures.
+const TINY_JPEG = Buffer.from(
+  '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0a' +
+  'HBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/wAALCAABAAEBAREA/8QAFAABAAAAAAAA' +
+  'AAAAAAAAAAAAB//EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAD8AfwD/2Q==', 'base64');
+function geoJpeg(file, meta) {
+  const exif = buildExif(meta);
+  const app1Len = exif.length + 2;
+  const app1 = Buffer.concat([Buffer.from([0xFF, 0xE1, (app1Len >> 8) & 0xff, app1Len & 0xff]), exif]);
+  fs.writeFileSync(file, Buffer.concat([TINY_JPEG.subarray(0, 2), app1, TINY_JPEG.subarray(2)]));
+}
+function plainJpeg(file) { fs.writeFileSync(file, TINY_JPEG); }
+
+const TRIP_YAML = `
+trip:
+  title: "Yosemite Weekend 2026"
+  dates: "May 15-16, 2026"
+  total_days: 2
+  total_stops: 4
+  origin: "Fresno, CA"
+  origin_lat: 36.7378
+  origin_lng: -119.7871
+days:
+  - number: 1
+    title: "Valley Floor"
+    date: "Friday, May 15"
+    status: completed
+    color: "#2e7db5"
+    lodging: { name: "Yosemite Valley Lodge", lat: 37.7456, lng: -119.5967 }
+    stops:
+      - { name: "Lower Yosemite Fall", lat: 37.7561, lng: -119.5966, type: hike, navigate_url: "https://maps.google.com/?q=lyf" }
+      - { name: "Tunnel View", lat: 37.7159, lng: -119.6770, type: scenic, navigate_url: "https://maps.google.com/?q=tv" }
+  - number: 2
+    title: "Mariposa Grove"
+    date: "Saturday, May 16"
+    status: completed
+    color: "#2d7a50"
+    lodging: { name: "Home", lat: 36.7378, lng: -119.7871 }
+    stops:
+      - { name: "Mariposa Grove", lat: 37.5142, lng: -119.6010, type: hike, navigate_url: "https://maps.google.com/?q=mg" }
+      - { name: "Glacier Point", lat: 37.7275, lng: -119.5734, type: scenic, navigate_url: "https://maps.google.com/?q=gp" }
+`;
+
+function main() {
+  console.log(`media lifecycle e2e${HAVE_SHARP ? '' : ' (sharp absent — thumbnail checks skipped)'}`);
+  const work = fs.mkdtempSync(path.join(os.tmpdir(), 'tripkit-media-'));
+  const TRIP = path.join(work, 'trip.yaml');
+  const MEDIA = path.join(work, 'media');
+  const REVIEW = path.join(work, 'trip.media-review.yaml');
+  try {
+    fs.writeFileSync(TRIP, TRIP_YAML);
+    fs.mkdirSync(MEDIA);
+
+    // PRE-TRIP
+    check('pre-trip validates clean', /is valid/.test(tk(['validate', TRIP])));
+    tk([TRIP, path.join(work, 'pre.html')]);
+    const preData = (() => { const h = fs.readFileSync(path.join(work, 'pre.html'), 'utf8'); return h.slice(h.indexOf('const TRIP_DATA ='), h.indexOf('END TRIP DATA')); })();
+    check('pre-trip TRIP_DATA has no media', !/"media"\s*:/.test(preData));
+
+    // FIXTURES (day-gated; May 15 = day 1, May 16 = day 2)
+    geoJpeg(path.join(MEDIA, 'fall_01.jpg'), { lat: 37.7560, lng: -119.5965, dateStr: '2026:05:15 10:15:00' });
+    geoJpeg(path.join(MEDIA, 'fall_02.jpg'), { lat: 37.7562, lng: -119.5968, dateStr: '2026:05:15 10:22:00' });
+    geoJpeg(path.join(MEDIA, 'tunnel_01.jpg'), { lat: 37.7160, lng: -119.6771, dateStr: '2026:05:15 16:45:00' });
+    geoJpeg(path.join(MEDIA, 'sequoia_01.jpg'), { lat: 37.5141, lng: -119.6011, dateStr: '2026:05:16 09:30:00' });
+    geoJpeg(path.join(MEDIA, 'random_sf.jpg'), { lat: 37.7749, lng: -122.4194, dateStr: '2026:05:16 12:00:00' }); // too far
+    plainJpeg(path.join(MEDIA, 'no_gps.jpg')); // no GPS
+
+    // INGEST
+    tk(['media', MEDIA, TRIP]);
+    const review = yaml.load(fs.readFileSync(REVIEW, 'utf8'));
+    check('review total = 6', review.summary.total === 6, JSON.stringify(review.summary));
+    check('review matched = 4', review.summary.matched === 4, JSON.stringify(review.summary));
+    check('review unmatched = 2', review.summary.unmatched === 2, JSON.stringify(review.summary));
+    const fall = review.stops.find(s => s.stop === 'Lower Yosemite Fall');
+    check('Lower Yosemite Fall = 2 photos, day 1 idx 0', fall && fall.media.length === 2 && fall.day === 1 && fall.stop_index === 0, JSON.stringify(fall && { n: fall.media.length, d: fall.day, i: fall.stop_index }));
+    check('Mariposa matched on day 2', !!review.stops.find(s => /Mariposa/.test(s.stop) && s.day === 2));
+    check('SF photo unmatched (too far)', review.unmatched.some(u => u.src.includes('random_sf')));
+    check('no-GPS photo unmatched', review.unmatched.some(u => u.src.includes('no_gps') && /no GPS/i.test(u.reason)));
+    soft('thumbnails generated', fs.existsSync(path.join(MEDIA, 'thumb', 'fall_01.jpg')));
+    soft('review item carries thumb path', fall && /thumb\//.test(fall.media[0].thumb || ''));
+
+    // REVIEW STEP: caption everything; promote SF photo onto Glacier Point (day 2 idx 1)
+    review.stops.forEach(s => s.media.forEach(m => { m.caption = `Photo at ${s.stop}`; }));
+    const sf = review.unmatched.find(u => u.src.includes('random_sf'));
+    sf.day = 2; sf.stop_index = 1; sf.caption = 'Manually placed';
+    fs.writeFileSync(REVIEW, yaml.dump(review));
+
+    // APPLY + idempotency
+    check('apply reports items applied', /Applied [1-9]\d* media/.test(tk(['media', 'apply', REVIEW, TRIP])));
+    const after = yaml.load(fs.readFileSync(TRIP, 'utf8'));
+    check('Lower Yosemite Fall has 2 media', (after.days[0].stops[0].media || []).length === 2);
+    check('captions merged', after.days[0].stops[0].media[0].caption === 'Photo at Lower Yosemite Fall');
+    check('promoted SF photo on Glacier Point', (after.days[1].stops[1].media || []).some(m => /random_sf/.test(m.src)));
+    check('apply is idempotent', /Applied 0 media/.test(tk(['media', 'apply', REVIEW, TRIP])));
+
+    // POST-TRIP: validate (no errors; far-GPS warning expected) + render
+    const { errors, warnings } = validate(yaml.load(fs.readFileSync(TRIP, 'utf8')));
+    check('post-trip has no validation errors', errors.length === 0, JSON.stringify(errors));
+    check('post-trip warns on far manual placement', warnings.some(w => /media GPS is \d+ mi/.test(w.message)), JSON.stringify(warnings));
+    tk([TRIP, path.join(work, 'post.html')]);
+    const post = fs.readFileSync(path.join(work, 'post.html'), 'utf8');
+    check('post render embeds media src', post.includes('fall_01.jpg'));
+    check('post render embeds caption', post.includes('Photo at Lower Yosemite Fall'));
+
+    console.log(failures === 0 ? '✓ media lifecycle e2e passed' : `✖ media lifecycle e2e: ${failures} assertion(s) failed`);
+  } finally {
+    fs.rmSync(work, { recursive: true, force: true });
+  }
+  process.exit(failures === 0 ? 0 : 1);
+}
+
+main();

package/validate.js

@@ -6,6 +6,9 @@
  */
 
 const STOP_TYPES = new Set(['hike', 'scenic', 'food', 'city', 'activity', 'beach', 'museum', 'shopping']);
+const MEDIA_TYPES = new Set(['photo', 'video']);
+// Distance above which a media item's own GPS looks suspiciously far from its stop.
+const MEDIA_FAR_MILES = 25;
 const DAY_STATUS = new Set(['completed', 'active', 'upcoming']);
 const MAP_STYLES = new Set(['terrain', 'satellite', 'topo', 'street']);
 const HEX = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
@@ -13,6 +16,63 @@ const HEX = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
 function isFiniteNumber(n) { return typeof n === 'number' && Number.isFinite(n); }
 function isNonEmptyString(s) { return typeof s === 'string' && s.trim().length > 0; }
 
+function distanceMiles(lat1, lng1, lat2, lng2) {
+  const toRad = (d) => d * Math.PI / 180;
+  const R = 3958.8;
+  const dLat = toRad(lat2 - lat1);
+  const dLng = toRad(lng2 - lng1);
+  const a = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) ** 2;
+  return 2 * R * Math.asin(Math.sqrt(a));
+}
+
+// Renderer auto-generates routes by stitching: prev-lodging → stops → today's-lodging.
+// Pick the same anchor the renderer would use for each end of a day's route.
+function dayEndAnchor(d) {
+  if (d.lodging && d.lodging.lat && d.lodging.lng && d.lodging.name !== 'Home') {
+    return [d.lodging.lat, d.lodging.lng, 'lodging'];
+  }
+  const stops = (d.stops || []).filter(s => isFiniteNumber(s.lat) && isFiniteNumber(s.lng));
+  if (stops.length > 0) {
+    const last = stops[stops.length - 1];
+    return [last.lat, last.lng, `stops[${stops.length - 1}]`];
+  }
+  return null;
+}
+function dayStartAnchor(d) {
+  const stops = (d.stops || []).filter(s => isFiniteNumber(s.lat) && isFiniteNumber(s.lng));
+  if (stops.length > 0) return [stops[0].lat, stops[0].lng, 'stops[0]'];
+  if (d.lodging && d.lodging.lat && d.lodging.lng && d.lodging.name !== 'Home') {
+    return [d.lodging.lat, d.lodging.lng, 'lodging'];
+  }
+  return null;
+}
+
+// Threshold above which a single straight-line polyline segment looks visually disjointed.
+const LONG_LEG_MILES = 250;
+
+// Validate an optional media[] array (on a stop or lodging). `anchor` is the
+// [lat, lng] of the owning stop/lodging, used to flag wildly-off media GPS.
+function validateMedia(media, basePath, anchor, err, warn) {
+  if (media == null) return;
+  if (!Array.isArray(media)) { err(`${basePath}.media`, 'must be an array when present'); return; }
+  media.forEach((m, mi) => {
+    const mp = `${basePath}.media[${mi}]`;
+    if (!m || typeof m !== 'object') { err(mp, 'must be an object'); return; }
+    if (!isNonEmptyString(m.src)) err(`${mp}.src`, 'required, non-empty string (relative path or URL)');
+    if (m.type != null && !MEDIA_TYPES.has(m.type)) {
+      err(`${mp}.type`, `must be one of ${[...MEDIA_TYPES].join(', ')}; got "${m.type}"`);
+    }
+    if (m.lat != null && (!isFiniteNumber(m.lat) || m.lat < -90 || m.lat > 90)) err(`${mp}.lat`, `must be a number in [-90, 90]; got ${m.lat}`);
+    if (m.lng != null && (!isFiniteNumber(m.lng) || m.lng < -180 || m.lng > 180)) err(`${mp}.lng`, `must be a number in [-180, 180]; got ${m.lng}`);
+    if (anchor && isFiniteNumber(m.lat) && isFiniteNumber(m.lng)) {
+      const miles = distanceMiles(anchor[0], anchor[1], m.lat, m.lng);
+      if (miles > MEDIA_FAR_MILES) {
+        warn(`${mp}`, `media GPS is ${Math.round(miles)} mi from its stop — likely matched to the wrong stop`);
+      }
+    }
+  });
+}
+
 function validate(data) {
   const errors = [];
   const warnings = [];
@@ -36,6 +96,21 @@ function validate(data) {
     if (trip.total_stops != null && !Number.isInteger(trip.total_stops)) {
       err('trip.total_stops', `must be an integer, got ${typeof trip.total_stops}`);
     }
+    const checkLatLng = (latKey, lngKey) => {
+      const lat = trip[latKey];
+      const lng = trip[lngKey];
+      if (lat != null && (!isFiniteNumber(lat) || lat < -90 || lat > 90)) {
+        err(`trip.${latKey}`, `must be a number in [-90, 90]; got ${lat}`);
+      }
+      if (lng != null && (!isFiniteNumber(lng) || lng < -180 || lng > 180)) {
+        err(`trip.${lngKey}`, `must be a number in [-180, 180]; got ${lng}`);
+      }
+      if ((lat != null) !== (lng != null)) {
+        err(`trip.${latKey}`, `both ${latKey} and ${lngKey} must be set together`);
+      }
+    };
+    checkLatLng('origin_lat', 'origin_lng');
+    checkLatLng('destination_lat', 'destination_lng');
   }
 
   // --- days ---
@@ -83,6 +158,8 @@ function validate(data) {
           if (s.kid_friendly != null && typeof s.kid_friendly !== 'boolean') {
             err(`${sp}.kid_friendly`, 'must be boolean');
           }
+          const anchor = isFiniteNumber(s.lat) && isFiniteNumber(s.lng) ? [s.lat, s.lng] : null;
+          validateMedia(s.media, sp, anchor, err, warn);
         });
       }
     }
@@ -104,6 +181,8 @@ function validate(data) {
       if (d.lodging.booked && !isHome && !isNonEmptyString(d.lodging.confirmation)) {
         warn(`${lp}.confirmation`, 'lodging is marked booked but confirmation is empty');
       }
+      const lodgeAnchor = isFiniteNumber(lat) && isFiniteNumber(lng) ? [lat, lng] : null;
+      validateMedia(d.lodging.media, lp, lodgeAnchor, err, warn);
     }
   });
 
@@ -115,6 +194,21 @@ function validate(data) {
     warn('trip.total_stops', `declared ${trip.total_stops}, actual stops = ${actualStops}`);
   }
 
+  // --- continuity check: warn on long inter-day jumps with no intermediate waypoint ---
+  if (data.routes == null) {
+    for (let i = 0; i + 1 < days.length; i++) {
+      const fromAnchor = dayEndAnchor(days[i]);
+      const toDay = days[i + 1];
+      const stops = (toDay.stops || []).filter(s => isFiniteNumber(s.lat) && isFiniteNumber(s.lng));
+      const toAnchor = stops.length > 0 ? [stops[0].lat, stops[0].lng] : dayStartAnchor(toDay);
+      if (!fromAnchor || !toAnchor) continue;
+      const miles = distanceMiles(fromAnchor[0], fromAnchor[1], toAnchor[0], toAnchor[1]);
+      if (miles > LONG_LEG_MILES) {
+        warn(`days[${i + 1}].stops`, `first stop is ${Math.round(miles)} mi from end of day ${i + 1} — auto-generated polyline will draw a long straight line. Add an intermediate stop or define a routes[] entry.`);
+      }
+    }
+  }
+
   // --- routes (optional) ---
   if (data.routes != null) {
     if (!Array.isArray(data.routes)) {
@@ -151,6 +245,9 @@ function validate(data) {
     if (data.theme.map_style != null && !MAP_STYLES.has(data.theme.map_style)) {
       err('theme.map_style', `must be one of ${[...MAP_STYLES].join(', ')}; got "${data.theme.map_style}"`);
     }
+    if (data.theme.hotel_label != null && (typeof data.theme.hotel_label !== 'string' || data.theme.hotel_label.length === 0 || data.theme.hotel_label.length > 4)) {
+      err('theme.hotel_label', 'must be a string of 1–4 characters (used as the hotel marker label)');
+    }
   }
 
   return { errors, warnings };

package/agent/AGENT-SKILL.md

@@ -1,105 +0,0 @@
-# TripKit Agent Skill
-# System prompt / skill for AI agents that plan trips using the TripKit framework.
-# Agent-agnostic: works with Claude, GPT, Gemini, or any capable LLM with web search.
-
-## Role
-
-You are a trip planning agent that creates detailed, actionable road trip and travel plans. You use the TripKit schema to produce structured YAML data that renders into beautiful interactive trip visualizers.
-
-## Workflow
-
-### Phase 1: Elicitation
-Use the questionnaire template (`agent/questionnaire.yaml`) to gather trip preferences conversationally. Don't interrogate — have a natural conversation. Extract as much as you can from the user's initial message before asking follow-ups.
-
-**Minimum viable input to start planning:**
-- Destination region
-- Dates / duration
-- Party size (adults + kids ages)
-- Starting point
-
-### Phase 2: Research & Draft
-With the basics in hand, research and produce a first draft:
-
-1. **Route research**: Search for driving routes, distances, and seasonal road conditions. Check for closures, construction, and permit requirements.
-2. **Attraction research**: Find top-rated stops along the route. Prioritize by user interests. Check hours, fees, seasonal availability, and age restrictions.
-3. **Lodging research**: Match user preferences (chain loyalty, budget, amenities). Compare options honestly — recommend the best fit, not just the first result.
-4. **Meal research**: Find restaurants near each stop. Prioritize local favorites over chains.
-5. **Produce YAML**: Generate a complete TripKit YAML file following the schema.
-
-### Phase 3: Render
-Convert the YAML to the interactive HTML visualizer. The visualizer includes:
-- Leaflet terrain map with day-colored route polylines
-- Numbered stop markers with popup details
-- Hotel markers (BW-style or chain-branded) with confirmation numbers
-- Day-by-day sidebar with weather, meals, lodging, alerts, tips
-- Map layer toggle (terrain / satellite / topo)
-
-### Phase 4: Iterate
-The plan WILL change. This is normal. Common iteration patterns:
-- **Rebalancing days**: One day too heavy, another too light → redistribute stops
-- **Swapping lodging**: Better option found → update with new confirmation
-- **Real-time adaptation**: Weather changes, road closures, fatigue → adjust same-day
-- **Adding/removing stops**: New discovery or running behind → flex the plan
-- **Schedule conflicts**: Work meetings, reservations → restructure around constraints
-
-Track all changes in `agent_context.iteration_log`. Each iteration should feel like sharpening, not starting over.
-
-## Critical Rules
-
-### Research Standards
-1. **Verify seasonal access**: Many parks, roads, and passes are closed seasonally. ALWAYS check.
-2. **Check age restrictions**: Venues, breweries, hot springs — verify before recommending for families.
-3. **Validate drive times**: Use actual routing, not straight-line estimates. Mountain roads average 30-40 mph, coastal roads 45-50 mph.
-4. **Confirm prices and fees**: Park entrance fees, parking fees, reservation requirements change yearly.
-5. **Cross-check with multiple sources**: One TripAdvisor review ≠ a recommendation.
-
-### Honest Recommendations
-1. **Be opinionated**: Don't list 5 equal options. Recommend the best one and explain why.
-2. **Flag tradeoffs**: "Astoria > Seaside because Goonies house + better character, but 20 min further from Cannon Beach."
-3. **Admit mistakes**: When a recommendation doesn't work (e.g., 21+ venue for families), own it, log it, and fix it.
-4. **Push back on bad ideas**: If the user wants to drive 14 hours with kids, suggest alternatives.
-5. **Respect fatigue**: After a big hiking day, don't plan another big hiking day.
-
-### Data Integrity
-1. **Confirmation numbers**: Only add when the user confirms booking. Never fabricate.
-2. **Weather**: Only add real forecasts close to travel date. Use placeholder text for future trips.
-3. **Navigation URLs**: Use Google Maps format: `https://www.google.com/maps/dir/?api=1&destination=...`
-4. **Coordinates**: Verify lat/lng are correct — a wrong decimal place puts a marker in the ocean.
-
-## Output Format
-
-Always produce a complete TripKit YAML file that conforms to `schema/tripkit.schema.yaml`. The YAML is the source of truth — the HTML renderer reads it.
-
-For embedded rendering (single-file HTML), convert the YAML to JSON and embed it in the HTML template. This is the fastest path to a shareable trip plan.
-
-## Example Iteration Patterns
-
-### "Can we push further north to save driving tomorrow?"
-→ Recalculate day split, rebalance stops, update lodging, re-render.
-
-### "We're tired, can we leave later?"
-→ Calculate time budget to hard stops (hotel check-in, meetings), identify skippable stops, provide revised schedule.
-
-### "Is that parking reservation required?"
-→ Search for current requirements, cite source, update alerts in YAML.
-
-### "What about [Alternative Hotel]?"
-→ Research, compare on price/location/amenities/loyalty, present tradeoff table, let user decide.
-
-### "We did [Stop X] already, remove from tomorrow"
-→ Update YAML, recalculate day timing, identify what the freed time enables.
-
-## Lessons Learned (from real trips)
-
-These patterns emerged from actual trip planning and should inform all future plans:
-
-1. **Day 1 is always the longest drive** — plan a light first evening, not an ambitious agenda.
-2. **Families run 30-60 min behind schedule** — build buffer, not precision.
-3. **The best stops are often unplanned** — leave 20% slack in each day.
-4. **Hotel chain loyalty matters** — 5 nights at one chain = meaningful points + consistent free breakfast.
-5. **Free breakfast saves $15-20/person/day** — it's a real budget factor for families.
-6. **One big hike per day max** — even fit families burn out on back-to-back heavy days.
-7. **Evening plans need kid-friendly verification** — breweries, hot springs, entertainment venues often have age restrictions that aren't obvious online.
-8. **Drive time estimates are optimistic** — add 15-20% for mountain/coastal roads, bathroom stops, and "ooh pull over" moments.
-9. **Weather changes everything** — check forecasts 2 days out and adapt. Rain at a lighthouse is different from rain on a hiking trail.
-10. **The iteration log is the most valuable artifact** — it captures decision rationale for next time.