ed-mcp 0.5.0 → 0.6.0

package/dist/index.js

@@ -103,7 +103,7 @@ var require_code = __commonJS({
     }
     exports._ = _;
     var plus = new _Code("+");
-    function str5(strs, ...args) {
+    function str6(strs, ...args) {
       const expr = [safeStringify(strs[0])];
       let i = 0;
       while (i < args.length) {
@@ -114,7 +114,7 @@ var require_code = __commonJS({
       optimize(expr);
       return new _Code(expr);
     }
-    exports.str = str5;
+    exports.str = str6;
     function addCodeArg(code, arg) {
       if (arg instanceof _Code)
         code.push(...arg._items);
@@ -157,7 +157,7 @@ var require_code = __commonJS({
       return;
     }
     function strConcat(c1, c2) {
-      return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str5`${c1}${c2}`;
+      return c2.emptyStr() ? c1 : c1.emptyStr() ? c2 : str6`${c1}${c2}`;
     }
     exports.strConcat = strConcat;
     function interpolate(x) {
@@ -1119,22 +1119,22 @@ var require_util = __commonJS({
       return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
     }
     exports.schemaRefOrVal = schemaRefOrVal;
-    function unescapeFragment(str5) {
-      return unescapeJsonPointer(decodeURIComponent(str5));
+    function unescapeFragment(str6) {
+      return unescapeJsonPointer(decodeURIComponent(str6));
     }
     exports.unescapeFragment = unescapeFragment;
-    function escapeFragment(str5) {
-      return encodeURIComponent(escapeJsonPointer(str5));
+    function escapeFragment(str6) {
+      return encodeURIComponent(escapeJsonPointer(str6));
     }
     exports.escapeFragment = escapeFragment;
-    function escapeJsonPointer(str5) {
-      if (typeof str5 == "number")
-        return `${str5}`;
-      return str5.replace(/~/g, "~0").replace(/\//g, "~1");
+    function escapeJsonPointer(str6) {
+      if (typeof str6 == "number")
+        return `${str6}`;
+      return str6.replace(/~/g, "~0").replace(/\//g, "~1");
     }
     exports.escapeJsonPointer = escapeJsonPointer;
-    function unescapeJsonPointer(str5) {
-      return str5.replace(/~1/g, "/").replace(/~0/g, "~");
+    function unescapeJsonPointer(str6) {
+      return str6.replace(/~1/g, "/").replace(/~0/g, "~");
     }
     exports.unescapeJsonPointer = unescapeJsonPointer;
     function eachItem(xs, f) {
@@ -2159,8 +2159,8 @@ var require_json_schema_traverse = __commonJS({
         post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
       }
     }
-    function escapeJsonPtr(str5) {
-      return str5.replace(/~/g, "~0").replace(/\//g, "~1");
+    function escapeJsonPtr(str6) {
+      return str6.replace(/~/g, "~0").replace(/\//g, "~1");
     }
   }
 });
@@ -3257,10 +3257,10 @@ var require_utils = __commonJS({
         isIPV6: true
       };
     }
-    function findToken(str5, token) {
+    function findToken(str6, token) {
       let ind = 0;
-      for (let i = 0; i < str5.length; i++) {
-        if (str5[i] === token) ind++;
+      for (let i = 0; i < str6.length; i++) {
+        if (str6[i] === token) ind++;
       }
       return ind;
     }
@@ -4330,7 +4330,7 @@ var require_core = __commonJS({
     var util_1 = require_util();
     var $dataRefSchema = require_data();
     var uri_1 = require_uri();
-    var defaultRegExp = (str5, flags) => new RegExp(str5, flags);
+    var defaultRegExp = (str6, flags) => new RegExp(str6, flags);
     defaultRegExp.code = "new RegExp";
     var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes"];
     var EXT_SCOPE_NAMES = /* @__PURE__ */ new Set([
@@ -5125,16 +5125,16 @@ var require_ucs2length = __commonJS({
   "node_modules/ajv/dist/runtime/ucs2length.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    function ucs2length(str5) {
-      const len = str5.length;
+    function ucs2length(str6) {
+      const len = str6.length;
       let length = 0;
       let pos = 0;
       let value;
       while (pos < len) {
         length++;
-        value = str5.charCodeAt(pos++);
+        value = str6.charCodeAt(pos++);
         if (value >= 55296 && value <= 56319 && pos < len) {
-          value = str5.charCodeAt(pos);
+          value = str6.charCodeAt(pos);
           if ((value & 64512) === 56320)
             pos++;
         }
@@ -7017,8 +7017,8 @@ var require_formats = __commonJS({
     }
     var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
     var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-    function date5(str5) {
-      const matches2 = DATE.exec(str5);
+    function date5(str6) {
+      const matches2 = DATE.exec(str6);
       if (!matches2)
         return false;
       const year = +matches2[1];
@@ -7037,8 +7037,8 @@ var require_formats = __commonJS({
     }
     var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
     function getTime(strictTimeZone) {
-      return function time3(str5) {
-        const matches2 = TIME.exec(str5);
+      return function time3(str6) {
+        const matches2 = TIME.exec(str6);
         if (!matches2)
           return false;
         const hr = +matches2[1];
@@ -7084,8 +7084,8 @@ var require_formats = __commonJS({
     var DATE_TIME_SEPARATOR = /t|\s/i;
     function getDateTime(strictTimeZone) {
       const time3 = getTime(strictTimeZone);
-      return function date_time(str5) {
-        const dateTime = str5.split(DATE_TIME_SEPARATOR);
+      return function date_time(str6) {
+        const dateTime = str6.split(DATE_TIME_SEPARATOR);
         return dateTime.length === 2 && date5(dateTime[0]) && time3(dateTime[1]);
       };
     }
@@ -7110,13 +7110,13 @@ var require_formats = __commonJS({
     }
     var NOT_URI_FRAGMENT = /\/|:/;
     var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
-    function uri(str5) {
-      return NOT_URI_FRAGMENT.test(str5) && URI.test(str5);
+    function uri(str6) {
+      return NOT_URI_FRAGMENT.test(str6) && URI.test(str6);
     }
     var BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm;
-    function byte(str5) {
+    function byte(str6) {
       BYTE.lastIndex = 0;
-      return BYTE.test(str5);
+      return BYTE.test(str6);
     }
     var MIN_INT32 = -(2 ** 31);
     var MAX_INT32 = 2 ** 31 - 1;
@@ -7130,11 +7130,11 @@ var require_formats = __commonJS({
       return true;
     }
     var Z_ANCHOR = /[^\\]\\Z/;
-    function regex(str5) {
-      if (Z_ANCHOR.test(str5))
+    function regex(str6) {
+      if (Z_ANCHOR.test(str6))
         return false;
       try {
-        new RegExp(str5);
+        new RegExp(str6);
         return true;
       } catch (e) {
         return false;
@@ -8095,14 +8095,14 @@ function promiseAllObject(promisesObj) {
 }
 function randomString(length = 10) {
   const chars = "abcdefghijklmnopqrstuvwxyz";
-  let str5 = "";
+  let str6 = "";
   for (let i = 0; i < length; i++) {
-    str5 += chars[Math.floor(Math.random() * chars.length)];
+    str6 += chars[Math.floor(Math.random() * chars.length)];
   }
-  return str5;
+  return str6;
 }
-function esc(str5) {
-  return JSON.stringify(str5);
+function esc(str6) {
+  return JSON.stringify(str6);
 }
 function slugify(input2) {
   return input2.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -8216,8 +8216,8 @@ var primitiveTypes = /* @__PURE__ */ new Set([
   "symbol",
   "undefined"
 ]);
-function escapeRegex(str5) {
-  return str5.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegex(str6) {
+  return str6.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function clone(inst, def, params) {
   const cl = new inst._zod.constr(def ?? inst._zod.def);
@@ -8483,13 +8483,13 @@ function getSizableOrigin(input2) {
   return "unknown";
 }
 var highSurrogate = /[\uD800-\uDBFF]/;
-function codePointLength(str5) {
-  const units = str5.length;
-  if (!highSurrogate.test(str5))
+function codePointLength(str6) {
+  const units = str6.length;
+  if (!highSurrogate.test(str6))
     return units;
   let count = units;
   for (let i = 0; i < units - 1; i++) {
-    if ((str5.charCodeAt(i) & 64512) === 55296 && (str5.charCodeAt(i + 1) & 64512) === 56320) {
+    if ((str6.charCodeAt(i) & 64512) === 55296 && (str6.charCodeAt(i + 1) & 64512) === 56320) {
       count--;
       i++;
     }
@@ -28752,7 +28752,7 @@ async function canonical(p) {
 }
 
 // src/version.ts
-var VERSION = "0.5.0";
+var VERSION = "0.6.0";
 
 // src/config.ts
 var ConfigError = class extends Error {
@@ -28817,6 +28817,7 @@ function loadConfig(env2, dirs, platform = process.platform) {
     legacyPlansEnv: get(env2, "ED_MCP_PLANS"),
     plansMarkdownDir: path3.join(dataDir, "plans"),
     prefsFile: path3.join(dataDir, "preferences.json"),
+    activityFile: path3.join(dataDir, "activity.json"),
     secretsFile: syncPassword ? path3.join(dataDir, "secrets.enc") : path3.join(dirs.config, "secrets.json"),
     locksDir: path3.join(dirs.config, "locks"),
     cacheDir: dirs.cache,
@@ -29754,8 +29755,8 @@ var Catalog = class {
         ).join(", ")}`
       );
     }
-    const same4 = m.trade_group ? this.d.materials.filter((x) => x.kind === m.kind && x.trade_group === m.trade_group).sort((a, b) => a.grade - b.grade) : [m];
-    return { ...m, same_group: same4, trade_rules: TRADE_RULES };
+    const same6 = m.trade_group ? this.d.materials.filter((x) => x.kind === m.kind && x.trade_group === m.trade_group).sort((a, b) => a.grade - b.grade) : [m];
+    return { ...m, same_group: same6, trade_rules: TRADE_RULES };
   }
   /** Coriolis feature ranges, [min, max], for a blueprint id at a grade on a module group, or null. */
   blueprintFeatures(blueprintId2, grade, grp) {
@@ -31701,6 +31702,333 @@ function buildState(events) {
   };
 }
 
+// src/journal/bodies.ts
+var BODY_EVENTS = [
+  "Scan",
+  "FSSDiscoveryScan",
+  "FSSAllBodiesFound",
+  "FSSBodySignals",
+  "SAASignalsFound",
+  "SAAScanComplete",
+  "ScanOrganic",
+  "SellOrganicData",
+  "Died"
+];
+var num3 = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var str3 = (v) => typeof v === "string" && v !== "" ? v : null;
+var objs2 = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "object" && x !== null) : [];
+var same = (a, b) => a !== null && a.toLowerCase() === b.toLowerCase();
+function systemAddress(events, system) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const e = events[i];
+    if (same(str3(e.StarSystem) ?? str3(e.SystemName), system)) {
+      const address = num3(e.SystemAddress);
+      if (address !== null) return address;
+    }
+  }
+  return null;
+}
+function signalsOf(e) {
+  return objs2(e.Signals).map((s) => ({
+    type: str3(s.Type_Localised) ?? str3(s.Type) ?? "unknown",
+    count: num3(s.Count) ?? 0
+  }));
+}
+function bioCount(e) {
+  return objs2(e.Signals).filter((s) => typeof s.Type === "string" && s.Type.endsWith("SignalType_Biological;")).reduce((n, s) => n + (num3(s.Count) ?? 0), 0);
+}
+function bodyNames(events, address) {
+  const names = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (num3(e.SystemAddress) !== address) continue;
+    const id = num3(e.BodyID);
+    const name = str3(e.BodyName);
+    if (id !== null && name) names.set(id, name);
+  }
+  return names;
+}
+function bodyMatches(name, system, wanted) {
+  if (!name) return false;
+  if (same(name, wanted)) return true;
+  return system !== null && same(name.slice(system.length).trim(), wanted);
+}
+function exobiology(events, address, opts = {}) {
+  const names = bodyNames(events, address);
+  const bodies = /* @__PURE__ */ new Map();
+  const body = (id) => {
+    let b = bodies.get(id);
+    if (!b) bodies.set(id, b = { bio: null, genera: /* @__PURE__ */ new Map(), species: /* @__PURE__ */ new Map() });
+    return b;
+  };
+  let unsold = 0;
+  let active2 = null;
+  const drop = () => {
+    if (active2?.species && !active2.species.analysed) {
+      active2.species.samples = 0;
+      active2.species.stage = "0/3";
+      active2.species.abandoned = true;
+    }
+    active2 = null;
+  };
+  for (const e of events) {
+    switch (e.event) {
+      case "SellOrganicData":
+        unsold = 0;
+        break;
+      case "Died":
+        unsold = 0;
+        drop();
+        break;
+      case "ScanOrganic": {
+        if (e.ScanType === "Analyse") unsold++;
+        const key = `${num3(e.SystemAddress)}|${num3(e.Body)}|${str3(e.Species)}`;
+        if (e.ScanType === "Log" && active2 && active2.key !== key) drop();
+        active2 = e.ScanType === "Analyse" ? null : { key, species: active2?.key === key ? active2.species : void 0 };
+        break;
+      }
+    }
+    if (num3(e.SystemAddress) !== address) continue;
+    switch (e.event) {
+      case "FSSBodySignals":
+      case "SAASignalsFound": {
+        const id = num3(e.BodyID);
+        if (id === null) break;
+        const count = bioCount(e);
+        if (count > 0 || bodies.has(id)) body(id).bio = count;
+        for (const g of objs2(e.Genuses)) {
+          const key = str3(g.Genus);
+          if (key) body(id).genera.set(key, str3(g.Genus_Localised) ?? key);
+        }
+        break;
+      }
+      case "ScanOrganic": {
+        const id = num3(e.Body);
+        const key = str3(e.Species);
+        if (id === null || !key) break;
+        const b = body(id);
+        const genusKey = str3(e.Genus) ?? "";
+        const s = b.species.get(key) ?? {
+          genus: str3(e.Genus_Localised) ?? genusKey,
+          genusKey,
+          species: str3(e.Species_Localised) ?? key,
+          variant: null,
+          samples: 0,
+          stage: "",
+          analysed: false
+        };
+        s.variant = str3(e.Variant_Localised) ?? s.variant;
+        if (e.ScanType === "Log") {
+          if (!s.analysed) s.samples = 1;
+          delete s.abandoned;
+        } else if (e.ScanType === "Sample") s.samples = Math.min(3, Math.max(2, s.samples + 1));
+        else if (e.ScanType === "Analyse") {
+          s.samples = 3;
+          s.analysed = true;
+        }
+        s.stage = `${s.samples}/3`;
+        b.species.set(key, s);
+        if (active2 && e.ScanType !== "Analyse") active2.species = s;
+        if (genusKey && !b.genera.has(genusKey)) b.genera.set(genusKey, s.genus);
+        break;
+      }
+    }
+  }
+  const out = [];
+  for (const [id, b] of bodies) {
+    const name = names.get(id) ?? `Body ${id}`;
+    if (opts.body && !bodyMatches(name, opts.system ?? null, opts.body)) continue;
+    const sampled = new Set(
+      [...b.species.values()].filter((s) => !s.abandoned).map((s) => s.genusKey)
+    );
+    out.push({
+      body: name,
+      body_id: id,
+      bio_signals: b.bio,
+      genera: [...b.genera.values()],
+      species: [...b.species.values()].map(({ genusKey: _, ...s }) => s),
+      not_started: [...b.genera].filter(([k]) => !sampled.has(k)).map(([, v]) => v)
+    });
+  }
+  out.sort((a, b) => a.body_id - b.body_id);
+  return { bodies: out, unsold_analysed: unsold };
+}
+function exploration(events, address) {
+  const discovery = {
+    body_count: null,
+    non_body_count: null,
+    progress: null,
+    all_bodies_found: false
+  };
+  const scans = /* @__PURE__ */ new Map();
+  const mapped = /* @__PURE__ */ new Set();
+  const signals = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (num3(e.SystemAddress) !== address) continue;
+    const id = num3(e.BodyID);
+    switch (e.event) {
+      case "FSSDiscoveryScan":
+        discovery.body_count = num3(e.BodyCount) ?? discovery.body_count;
+        discovery.non_body_count = num3(e.NonBodyCount) ?? discovery.non_body_count;
+        discovery.progress = num3(e.Progress) ?? discovery.progress;
+        break;
+      case "FSSAllBodiesFound":
+        discovery.all_bodies_found = true;
+        discovery.body_count = num3(e.Count) ?? discovery.body_count;
+        break;
+      case "Scan":
+        if (id !== null) scans.set(id, e);
+        break;
+      case "SAAScanComplete":
+        if (id !== null) mapped.add(id);
+        break;
+      case "FSSBodySignals":
+      case "SAASignalsFound":
+        if (id !== null) signals.set(id, signalsOf(e));
+        break;
+    }
+  }
+  const bodies = [...scans].map(([id, s]) => {
+    const distance2 = num3(s.DistanceFromArrivalLS);
+    return {
+      body: str3(s.BodyName) ?? `Body ${id}`,
+      body_id: id,
+      // Belt clusters have neither a planet class nor a star type.
+      type: str3(s.PlanetClass) ?? (str3(s.StarType) ? `${s.StarType} star` : null),
+      distance_ls: distance2 === null ? null : Math.round(distance2),
+      landable: s.Landable === true,
+      terraformable: s.TerraformState === "Terraformable",
+      atmosphere: str3(s.Atmosphere),
+      rings: objs2(s.Rings).map((r) => ({
+        name: str3(r.Name) ?? "unknown",
+        class: str3(r.RingClass)?.replace(/^eRingClass_/, "") ?? null
+      })),
+      was_discovered: typeof s.WasDiscovered === "boolean" ? s.WasDiscovered : null,
+      was_mapped: typeof s.WasMapped === "boolean" ? s.WasMapped : null,
+      mapped_by_you: mapped.has(id),
+      signals: signals.get(id) ?? []
+    };
+  });
+  bodies.sort((a, b) => (a.distance_ls ?? Infinity) - (b.distance_ls ?? Infinity));
+  return { discovery, scanned: bodies.length, bodies };
+}
+
+// src/journal/events.ts
+var MAX_ARRAY = 20;
+function truncate(value) {
+  if (Array.isArray(value)) {
+    const kept = value.slice(0, MAX_ARRAY).map(truncate);
+    if (value.length > MAX_ARRAY) kept.push(`(${value.length - MAX_ARRAY} more not shown)`);
+    return kept;
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, truncate(v)]));
+  }
+  return value;
+}
+var LOCATION_EVENTS = /* @__PURE__ */ new Set([
+  "Location",
+  "FSDJump",
+  "CarrierJump",
+  "Docked"
+]);
+function systemAt(locations, timestamp) {
+  for (let i = locations.length - 1; i >= 0; i--) {
+    const e = locations[i];
+    if (e.timestamp <= timestamp && typeof e.StarSystem === "string") return e.StarSystem;
+  }
+  return null;
+}
+function matchFile(events, filter, start = null) {
+  const names = filter.events?.length ? new Set(filter.events.map((n) => n.toLowerCase())) : void 0;
+  const system = filter.system?.toLowerCase();
+  let current = start?.toLowerCase() ?? null;
+  const out = [];
+  for (const e of events) {
+    if (LOCATION_EVENTS.has(e.event) && typeof e.StarSystem === "string") {
+      current = e.StarSystem.toLowerCase();
+    }
+    if (names && !names.has(e.event.toLowerCase())) continue;
+    if (filter.since !== void 0 && !(Date.parse(e.timestamp) >= filter.since)) continue;
+    if (system !== void 0) {
+      const own2 = e.event === "StartJump" ? void 0 : e.StarSystem ?? e.SystemName;
+      const at = typeof own2 === "string" ? own2.toLowerCase() : current;
+      if (at !== system) continue;
+    }
+    out.push(e);
+  }
+  return out;
+}
+
+// src/journal/massacre.ts
+var MASSACRE_EVENTS = [
+  "Bounty",
+  "FactionKillBond",
+  "MissionRedirected"
+];
+var same2 = (a, b) => a.toLowerCase() === b.toLowerCase();
+function massacre(missions, events) {
+  const tracked = missions.filter((m) => (m.kill_count ?? 0) > 0 && m.target_faction && m.accepted).map((m) => ({
+    mission: m,
+    out: {
+      id: m.id,
+      name: m.name,
+      accepted: m.accepted,
+      expires: m.expires,
+      reward: m.reward,
+      kills_required: m.kill_count,
+      kills_counted: 0,
+      kills_left: m.kill_count,
+      done: false
+    }
+  })).sort((a, b) => a.out.accepted.localeCompare(b.out.accepted) || a.out.id - b.out.id);
+  const uncounted = missions.filter((m) => m.details_missing && /massacre/i.test(m.name));
+  const byId = new Map(tracked.map((t) => [t.out.id, t]));
+  for (const e of events) {
+    if (e.event === "MissionRedirected") {
+      const t = byId.get(typeof e.MissionID === "number" ? e.MissionID : -1);
+      if (t?.mission.status === "complete") t.out.done = true;
+      continue;
+    }
+    if (e.event !== "Bounty" && e.event !== "FactionKillBond") continue;
+    const victim = typeof e.VictimFaction === "string" ? e.VictimFaction : null;
+    if (!victim) continue;
+    const credited = /* @__PURE__ */ new Set();
+    for (const { mission, out } of tracked) {
+      const giver = mission.faction ?? "";
+      if (credited.has(giver) || out.done || out.accepted > e.timestamp) continue;
+      if (!same2(mission.target_faction, victim)) continue;
+      out.kills_counted++;
+      credited.add(giver);
+      if (out.kills_counted >= out.kills_required) out.done = true;
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const { mission, out } of tracked) {
+    if (mission.status === "complete") out.done = true;
+    out.kills_left = out.done ? 0 : out.kills_required - out.kills_counted;
+    const target = mission.target_faction;
+    const giver = mission.faction ?? "unknown";
+    const byGiver = groups.get(target) ?? /* @__PURE__ */ new Map();
+    groups.set(target, byGiver);
+    byGiver.set(giver, [...byGiver.get(giver) ?? [], out]);
+  }
+  return {
+    groups: [...groups].map(([target, byGiver]) => {
+      const factions = [...byGiver].map(([faction, list2]) => ({
+        faction,
+        kills_left: list2.reduce((n, m) => n + m.kills_left, 0),
+        missions: list2
+      }));
+      return {
+        target_faction: target,
+        kills_left: Math.max(0, ...factions.map((f) => f.kills_left)),
+        factions
+      };
+    }),
+    uncounted
+  };
+}
+
 // src/journal/service.ts
 function errText(err) {
   return err.code ?? err.message ?? String(err);
@@ -31712,6 +32040,12 @@ function staleWarning(minutes2) {
 var STATE_WINDOW_MS = 14 * 864e5;
 var FRESH_MS = 864e5;
 var MEMO_MS = 1e3;
+var RAW_CACHE_FILES = 2;
+var KEPT_EVENTS = /* @__PURE__ */ new Set([
+  ...STATE_EVENTS,
+  ...BODY_EVENTS,
+  ...MASSACRE_EVENTS
+]);
 var STATION_FILES = {
   market: "Market.json",
   outfitting: "Outfitting.json",
@@ -31720,11 +32054,12 @@ var STATION_FILES = {
 var JournalService = class {
   constructor(dir, opts = {}) {
     this.dir = dir;
-    this.reader = opts.reader ?? new JournalReader({ keep: STATE_EVENTS });
+    this.reader = opts.reader ?? new JournalReader({ keep: KEPT_EVENTS });
     this.now = opts.now ?? Date.now;
   }
   dir;
   reader;
+  rawReader = new JournalReader();
   now;
   // Timed with performance.now so an injected test clock cannot freeze it.
   memo;
@@ -31850,7 +32185,37 @@ var JournalService = class {
     const ageMinutes = Number.isNaN(age) ? null : Math.max(0, Math.round(age / 6e4));
     if (ageMinutes !== null && age > STALE_MS) warnings.push(staleWarning(ageMinutes));
     const loadout = events.findLast((e) => e.event === "Loadout") ?? null;
-    return { ...state, age_minutes: ageMinutes, warnings, loadout };
+    return { ...state, age_minutes: ageMinutes, warnings, loadout, events };
+  }
+  /**
+   * Every recorded event that matches, newest first, from the state window. Files are read newest
+   * first and reading stops once the limit is reached or the files are older than since.
+   */
+  async recentEvents(filter, limit) {
+    const found = await this.files(STATE_WINDOW_MS);
+    if (!("files" in found)) throw new UserError(`${found.missing}. Run journal_status for help.`);
+    if (found.error) throw new UserError(`${found.error}. Run journal_status for help.`);
+    const warnings = [];
+    const out = [];
+    const locations = filter.system ? (await this.state()).events.filter((e) => LOCATION_EVENTS.has(e.event)) : [];
+    for (const file2 of [...found.files].reverse()) {
+      if (out.length >= limit) break;
+      let events;
+      try {
+        events = await this.rawReader.read(file2);
+      } catch (err) {
+        warnings.push(`Cannot read ${file2.name}: ${errText(err)}`);
+        continue;
+      }
+      const first = events[0];
+      const start = first && filter.system ? systemAt(locations, first.timestamp) : null;
+      const matched = matchFile(events, filter, start);
+      for (let i = matched.length - 1; i >= 0 && out.length < limit; i--) out.push(matched[i]);
+      const last = events.at(-1);
+      if (filter.since !== void 0 && last && Date.parse(last.timestamp) < filter.since) break;
+    }
+    this.rawReader.retain(found.files.slice(-RAW_CACHE_FILES).map((f) => f.path));
+    return { events: out, warnings };
   }
   // Newer game builds keep the cargo list here instead of in the Cargo event. Syncthing can
   // deliver the logs before this file, so a file older than the newest Cargo event is ignored.
@@ -31894,16 +32259,16 @@ var JournalService = class {
     const f = await this.stationFile("market");
     if (!f) return null;
     const items = Array.isArray(f.data.Items) ? f.data.Items : [];
-    const num6 = (v) => typeof v === "number" ? v : 0;
+    const num7 = (v) => typeof v === "number" ? v : 0;
     const rows = [];
     for (const i of items) {
       const name = i.Name_Localised ?? i.Name;
       if (typeof name !== "string") continue;
       rows.push({
         commodity: name,
-        buy_price: num6(i.BuyPrice),
-        sell_price: num6(i.SellPrice),
-        supply: num6(i.Stock),
+        buy_price: num7(i.BuyPrice),
+        sell_price: num7(i.SellPrice),
+        supply: num7(i.Stock),
         demand: marketDemand(i)
       });
     }
@@ -32176,7 +32541,10 @@ function mapSystem(raw) {
       name: s.name,
       type: s.type ?? null,
       pad: stationPad(s),
-      arrival_ls: s.distance_to_arrival ?? null
+      arrival_ls: s.distance_to_arrival ?? null,
+      // System search gives service names; station search gives { name } objects.
+      services: (s.services ?? []).map((x2) => typeof x2 === "string" ? x2 : x2.name),
+      owner: s.controlling_minor_faction ?? null
     })),
     stars: (raw.bodies ?? []).filter((b) => b.type === "Star").map((b) => ({ name: b.name, arrival_ls: b.distance_to_arrival ?? 0 }))
   };
@@ -32201,12 +32569,32 @@ var SweepCache = class {
   find(centre, radiusLy) {
     this.dropExpired();
     const hit = this.sweeps.find(
-      (s) => distanceLy(s.centre, centre) + radiusLy <= s.radiusLy + 1e-9
+      (s) => distanceLy(s.centre, centre) + radiusLy <= s.coveredLy + 1e-9
     );
     return hit?.systems.filter((s) => distanceLy(s.coords, centre) <= radiusLy);
   }
-  add(centre, radiusLy, systems) {
-    this.sweeps.push({ centre, radiusLy, systems, storedAt: this.now() });
+  add(centre, radiusLy, systems, key) {
+    const storedAt = key ? this.sweeps.find((s) => s.resume?.key === key)?.storedAt : void 0;
+    if (key) this.sweeps = this.sweeps.filter((s) => s.resume?.key !== key);
+    this.push({ centre, coveredLy: radiusLy, systems, storedAt: storedAt ?? this.now() });
+  }
+  savePartial(p) {
+    const storedAt = this.sweeps.find((s) => s.resume?.key === p.key)?.storedAt ?? this.now();
+    this.sweeps = this.sweeps.filter((s) => s.resume?.key !== p.key);
+    this.push({
+      centre: p.centre,
+      coveredLy: p.coveredLy,
+      systems: p.systems,
+      storedAt,
+      resume: p
+    });
+  }
+  partial(key) {
+    this.dropExpired();
+    return this.sweeps.find((s) => s.resume?.key === key)?.resume;
+  }
+  push(s) {
+    this.sweeps.push(s);
     while (this.sweeps.length > this.maxSweeps) this.sweeps.shift();
   }
   clear() {
@@ -32216,7 +32604,7 @@ var SweepCache = class {
   }
   stats() {
     this.dropExpired();
-    const oldest = this.sweeps[0]?.storedAt;
+    const oldest = this.sweeps.length ? Math.min(...this.sweeps.map((s) => s.storedAt)) : void 0;
     return {
       name: this.name,
       entries: this.sweeps.length,
@@ -32306,6 +32694,7 @@ var SpanshClient = class {
     this.systemCache = opts.systemCache ?? cache;
     this.marketCache = opts.marketCache ?? cache;
     this.sweepCache = opts.sweepCache ?? new SweepCache();
+    this.warCache = opts.warCache ?? cache;
   }
   http;
   cache;
@@ -32317,11 +32706,13 @@ var SpanshClient = class {
   systemCache;
   marketCache;
   sweepCache;
+  warCache;
   // Job ids by route form, so a call after a timeout collects the job instead of resubmitting.
   routeJobs = /* @__PURE__ */ new Map();
   tradeJobs = /* @__PURE__ */ new Map();
   tradeSubmits = /* @__PURE__ */ new Map();
   sweeps = /* @__PURE__ */ new Map();
+  warSearches = /* @__PURE__ */ new Map();
   gate = Promise.resolve();
   lastStart = 0;
   async resolveShip(name) {
@@ -32430,25 +32821,96 @@ var SpanshClient = class {
     );
     return detail.record.needs_permit ?? null;
   }
-  /** Populated systems within radiusLy of near. Stops paging at opts.deadline; a partial result is not cached. */
+  /** Populated systems within radiusLy of near. Stops paging at opts.deadline; a partial result is cached and the next call resumes it. */
   async populatedSystems(near, radiusLy, opts = {}) {
     const centre = (await this.system(near, 0)).coords;
     const cached2 = this.sweepCache.find(centre, radiusLy);
-    if (cached2) return { centre, systems: cached2, total: cached2.length, partial: false };
+    if (cached2)
+      return { centre, systems: cached2, total: cached2.length, partial: false, coveredLy: radiusLy };
     const key = `${near.toLowerCase()}:${radiusLy}`;
     let running = this.sweeps.get(key);
     if (!running) {
-      running = this.sweepPages(near, radiusLy, centre, opts).finally(
+      running = this.sweepPages(near, radiusLy, centre, key, opts).finally(
         () => this.sweeps.delete(key)
       );
       this.sweeps.set(key, running);
     }
     return running;
   }
-  async sweepPages(near, radiusLy, centre, opts) {
+  async sweepPages(near, radiusLy, centre, key, opts) {
+    const resume = this.sweepCache.partial(key);
+    const systems = resume ? [...resume.systems] : [];
+    const seen = new Set(systems.map((s) => s.id64));
+    let total = resume?.total ?? 0;
+    let partial2 = false;
+    for (let page2 = 0; ; page2++) {
+      if (page2 > 0 && opts.deadline !== void 0 && this.now() >= opts.deadline) {
+        partial2 = true;
+        break;
+      }
+      const body = {
+        filters: {
+          // Resuming by distance, not page: Spansh's list can shift between calls an hour apart.
+          distance: { min: resume?.coveredLy ?? 0, max: radiusLy },
+          population: { comparison: "<=>", value: [1, 1e11] }
+        },
+        sort: [{ distance: { direction: "asc" } }],
+        size: SWEEP_PAGE_SIZE,
+        page: page2,
+        reference_system: near
+      };
+      let res;
+      try {
+        res = await this.post("/systems/search", JSON.stringify(body), "application/json");
+      } catch (err) {
+        if (err instanceof SpanshError && err.status === 400) {
+          throw new UserError(
+            `Spansh rejected the search (${err.detail}). Check that "${near}" is an exact system name (spansh_system).`
+          );
+        }
+        throw err;
+      }
+      if (!resume) total = res.count;
+      const results = res.results ?? [];
+      for (const raw of results) {
+        const s = mapSystem(raw);
+        if (s && !seen.has(s.id64)) {
+          seen.add(s.id64);
+          systems.push(s);
+        }
+      }
+      if (results.length < SWEEP_PAGE_SIZE) break;
+    }
+    if (!partial2) {
+      this.sweepCache.add(centre, radiusLy, systems, key);
+      return { centre, systems, total, partial: partial2, coveredLy: radiusLy };
+    }
+    const last = systems[systems.length - 1];
+    const coveredLy = Math.max(
+      resume?.coveredLy ?? 0,
+      last ? distanceLy(last.coords, centre) - 0.01 : 0
+    );
+    this.sweepCache.savePartial({ key, centre, coveredLy, systems, total });
+    return { centre, systems, total, partial: partial2, coveredLy };
+  }
+  /** Systems within radiusLy of near with a faction at war and a Frontline Solutions station. */
+  async frontlineWarSystems(near, radiusLy, opts = {}) {
+    const centre = (await this.system(near, 0)).coords;
+    const key = `wars:${near.toLowerCase()}:${radiusLy}`;
+    const hit = this.warCache.get(key);
+    if (hit) return { centre, systems: hit, partial: false };
+    let running = this.warSearches.get(key);
+    if (!running) {
+      running = this.warPages(near, radiusLy, centre, key, opts).finally(
+        () => this.warSearches.delete(key)
+      );
+      this.warSearches.set(key, running);
+    }
+    return running;
+  }
+  async warPages(near, radiusLy, centre, key, opts) {
     const systems = [];
     const seen = /* @__PURE__ */ new Set();
-    let total = 0;
     let partial2 = false;
     for (let page2 = 0; ; page2++) {
       if (page2 > 0 && opts.deadline !== void 0 && this.now() >= opts.deadline) {
@@ -32458,7 +32920,8 @@ var SpanshClient = class {
       const body = {
         filters: {
           distance: { min: 0, max: radiusLy },
-          population: { comparison: "<=>", value: [1, 1e11] }
+          minor_faction_presences: [{ state: { value: ["War", "Civil War"] } }],
+          stations: [{ services: { value: ["Frontline Solutions"] } }]
         },
         sort: [{ distance: { direction: "asc" } }],
         size: SWEEP_PAGE_SIZE,
@@ -32476,7 +32939,6 @@ var SpanshClient = class {
         }
         throw err;
       }
-      total = res.count;
       const results = res.results ?? [];
       for (const raw of results) {
         const s = mapSystem(raw);
@@ -32487,8 +32949,28 @@ var SpanshClient = class {
       }
       if (results.length < SWEEP_PAGE_SIZE) break;
     }
-    if (!partial2) this.sweepCache.add(centre, radiusLy, systems);
-    return { centre, systems, total, partial: partial2 };
+    if (!partial2) this.warCache.set(key, systems);
+    return { centre, systems, partial: partial2 };
+  }
+  /** The bodies of a system, with the stations and settlements on each. Bodies rarely change. */
+  async systemBodies(id64) {
+    return await this.systemCache.getOrLoad(
+      `bodies:${id64}`,
+      async () => {
+        const raw = await this.get(`/dump/${id64}`);
+        const bodies = raw.system?.bodies ?? raw.bodies ?? [];
+        return bodies.map((b) => ({
+          name: b.name,
+          bodyId: b.bodyId,
+          subType: b.subType ?? null,
+          arrival_ls: b.distanceToArrival ?? 0,
+          parentPlanetId: (b.parents ?? []).map((p) => p.Planet).find((x) => x !== void 0) ?? null,
+          stations: (b.stations ?? []).map((s) => s.name)
+        }));
+      },
+      // An empty list is probably a dump that was not ready yet; fetch it again next time.
+      { keep: (b) => b.length > 0 }
+    );
   }
   async route(q, opts = {}) {
     const form = new URLSearchParams({
@@ -32891,10 +33373,8 @@ function mapRoute(r) {
   };
 }
 
-// src/plans/store.ts
-import { randomBytes as randomBytes2 } from "crypto";
-import { lstat as lstat2, mkdir as mkdir3, rename as rename3, rm, writeFile as writeFile3 } from "fs/promises";
-import path8 from "path";
+// src/activity/store.ts
+import { lstat as lstat2, mkdir as mkdir3, unlink as unlink2 } from "fs/promises";
 
 // src/fs/lock.ts
 import { createHash as createHash2, randomUUID } from "crypto";
@@ -33058,6 +33538,276 @@ async function failure2(err, file2) {
   return { kind: "unsafe", reason: `not readable (${code ?? "unknown error"})` };
 }
 
+// src/plans/schema.ts
+var ItemKind = external_exports.enum([
+  "buy",
+  "engineer",
+  "experimental",
+  "unlock_engineer",
+  "gather",
+  "trade",
+  "refit"
+]);
+var ItemStatus = external_exports.enum(["todo", "in_progress", "done", "skipped"]);
+var PlanItemSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  kind: ItemKind,
+  description: external_exports.string().min(1),
+  status: ItemStatus.default("todo"),
+  station: external_exports.string().optional(),
+  engineer: external_exports.string().optional(),
+  materials: external_exports.array(external_exports.object({ name: external_exports.string().min(1), count: external_exports.number().int().positive() })).optional(),
+  notes: external_exports.string().optional()
+});
+var StopKind = external_exports.enum([
+  "shop",
+  "trader",
+  "engineer",
+  "exobiology",
+  "exploration",
+  "combat",
+  "mission",
+  "hand_in",
+  "trade",
+  "mining",
+  "fuel",
+  "other"
+]);
+var StopStatus = external_exports.enum(["todo", "done", "skipped"]);
+var StopSchema = external_exports.object({
+  system: external_exports.string().min(1),
+  // Older files can hold station "", which named nothing; it reads as no station.
+  station: external_exports.string().transform((v) => v === "" ? void 0 : v).optional(),
+  body: external_exports.string().min(1).optional(),
+  purpose: external_exports.string().min(1),
+  label: external_exports.string().min(1).optional(),
+  kind: StopKind.optional(),
+  after: external_exports.array(external_exports.string().min(1)).optional(),
+  status: StopStatus.default("todo"),
+  notes: external_exports.string().optional()
+});
+var PlanRouteSchema = external_exports.object({
+  computed_at: external_exports.string(),
+  from: external_exports.string(),
+  stops: external_exports.array(external_exports.string()),
+  total_min: external_exports.number(),
+  plotted: external_exports.boolean(),
+  // For each entry of stops, the indexes in the plan's stops that it visits. Names alone do not
+  // map back: an engineer stop takes the engineer's name, and repeated names get -2, -3.
+  // Optional, so routes saved before it load.
+  stop_indexes: external_exports.array(external_exports.array(external_exports.number().int().min(0))).optional()
+});
+var PlanId = external_exports.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/, "id must be lowercase letters, digits and dashes");
+var PlanInputSchema = external_exports.object({
+  id: PlanId,
+  name: external_exports.string().min(1),
+  target_build: external_exports.unknown().optional(),
+  items: external_exports.array(PlanItemSchema).default([]),
+  stops: external_exports.array(StopSchema).default([]),
+  route: PlanRouteSchema.optional(),
+  notes: external_exports.string().optional()
+});
+var PlanSchema = PlanInputSchema.extend({
+  created_at: external_exports.string(),
+  updated_at: external_exports.string()
+});
+var PlanFileSchema = external_exports.object({
+  version: external_exports.literal(1),
+  plans: external_exports.array(PlanSchema)
+});
+
+// src/activity/schema.ts
+var ActivityKind = external_exports.enum([
+  "exobiology",
+  "exploration",
+  "massacre",
+  "missions",
+  "hauling",
+  "trading",
+  "mining",
+  "engineering",
+  "combat",
+  "other"
+]);
+var MAX_SUMMARY = 500;
+var ActivityInputSchema = external_exports.object({
+  kind: ActivityKind,
+  summary: external_exports.string().trim().min(1).max(MAX_SUMMARY),
+  // Bounded like the other fields, so the note cannot outgrow the size limit for data files.
+  plan_id: PlanId.optional()
+});
+var ActivitySchema = ActivityInputSchema.extend({
+  updated_at: external_exports.string()
+});
+var ActivityFileSchema = ActivitySchema.extend({ version: external_exports.literal(1) });
+
+// src/activity/store.ts
+var LOCK_TIMEOUT_MS = 5e3;
+var LOCKED = "Activity file is locked by another process; try again";
+var ActivityStore = class {
+  constructor(file2, now = () => /* @__PURE__ */ new Date(), opts = {}) {
+    this.file = file2;
+    this.now = now;
+    this.lockTimeoutMs = opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS;
+    this.lockDir = opts.lockDir;
+    this.guard = opts.guard;
+  }
+  file;
+  now;
+  queue = Promise.resolve();
+  lockTimeoutMs;
+  lockDir;
+  guard;
+  /** The saved note, or null when there is none. */
+  async get() {
+    await this.guard?.();
+    const read2 = await readRegularText(this.file, MAX_DATA_FILE);
+    if (read2.kind === "missing") return null;
+    if (read2.kind === "unsafe") {
+      throw new UserError(`Activity file ${this.file} is invalid: ${read2.reason}`);
+    }
+    let json3;
+    try {
+      json3 = JSON.parse(read2.text);
+    } catch {
+      throw new UserError(`Activity file ${this.file} is invalid: not JSON`);
+    }
+    const r = ActivityFileSchema.safeParse(json3);
+    if (!r.success) {
+      throw new UserError(`Activity file ${this.file} is invalid: ${external_exports.prettifyError(r.error)}`);
+    }
+    const { kind: kind2, summary, plan_id, updated_at } = r.data;
+    return { kind: kind2, summary, ...plan_id === void 0 ? {} : { plan_id }, updated_at };
+  }
+  /** Replaces the note. */
+  set(input2) {
+    return this.serial(async () => {
+      const parsed = ActivityInputSchema.safeParse(input2);
+      if (!parsed.success) {
+        throw new UserError(`Invalid activity: ${external_exports.prettifyError(parsed.error)}`);
+      }
+      const activity = { ...parsed.data, updated_at: this.now().toISOString() };
+      await this.guard?.();
+      return lockedWrite(
+        this.file,
+        { timeoutMs: this.lockTimeoutMs, lockDir: this.lockDir, lockedMessage: LOCKED },
+        async () => ({
+          content: JSON.stringify({ version: 1, ...activity }, null, 2),
+          result: activity
+        })
+      );
+    });
+  }
+  /** Deletes the note. Returns false when there was none. */
+  clear() {
+    return this.serial(async () => {
+      await this.guard?.();
+      const missing = await lstat2(this.file).then(
+        () => false,
+        (err) => {
+          if (err.code === "ENOENT") return true;
+          throw err;
+        }
+      );
+      if (missing) return false;
+      if (this.lockDir) await mkdir3(this.lockDir, { recursive: true });
+      const release = await acquireLock(this.file, this.lockTimeoutMs, LOCKED, this.lockDir);
+      try {
+        await unlink2(this.file);
+        return true;
+      } catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") return false;
+        if (code === "EPERM" || code === "EACCES" || code === "EBUSY") {
+          throw new UserError("Activity file is in use by another program; try again");
+        }
+        throw err;
+      } finally {
+        await release();
+      }
+    });
+  }
+  // One change at a time in this process; the lock file covers other processes.
+  serial(fn) {
+    const run = this.queue.then(fn);
+    this.queue = run.catch(() => void 0);
+    return run;
+  }
+};
+
+// src/plans/store.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { lstat as lstat3, mkdir as mkdir4, rename as rename3, rm, writeFile as writeFile3 } from "fs/promises";
+import path8 from "path";
+
+// src/plans/stops.ts
+var lc = (s) => s.toLowerCase();
+function stopName(s) {
+  return s.label ?? s.station ?? s.body ?? s.system;
+}
+function namesOf(s) {
+  return [s.label, s.station, s.body, s.system].flatMap((n) => n ? [lc(n)] : []);
+}
+function visitOrder(plan) {
+  const all = plan.stops.map((_, i) => i);
+  const route = plan.route;
+  if (!route) return all;
+  const used = /* @__PURE__ */ new Set();
+  const order = [];
+  const take = (i) => {
+    if (i === void 0 || used.has(i) || i >= plan.stops.length) return false;
+    used.add(i);
+    order.push(i);
+    return true;
+  };
+  if (route.stop_indexes && route.stop_indexes.length === route.stops.length) {
+    for (const entry2 of route.stop_indexes) for (const i of entry2) take(i);
+  } else {
+    const primary = plan.stops.map((s) => lc(stopName(s)));
+    for (const raw of route.stops) {
+      const name = lc(raw);
+      if (take(all.find((j) => !used.has(j) && primary[j] === name))) continue;
+      const m = /^(.*)-(\d+)$/.exec(name);
+      if (m && take(all.filter((j) => primary[j] === m[1])[Number(m[2]) - 1])) continue;
+      take(all.find((j) => !used.has(j) && namesOf(plan.stops[j]).includes(name)));
+    }
+  }
+  return [...order, ...all.filter((i) => !used.has(i))];
+}
+function nextStop(plan) {
+  const i = visitOrder(plan).find((j) => plan.stops[j].status === "todo");
+  return i === void 0 ? null : { index: i, ...plan.stops[i] };
+}
+function findStop(plan, ref) {
+  if (ref.label === void 0 && ref.index === void 0) {
+    throw new UserError("Give the stop's label or its index");
+  }
+  if (ref.label !== void 0 && ref.index !== void 0) {
+    throw new UserError("Give the stop's label or its index, not both");
+  }
+  if (plan.stops.length === 0) throw new UserError(`Plan "${plan.id}" has no stops.`);
+  if (ref.index !== void 0) {
+    if (!Number.isInteger(ref.index) || ref.index < 0 || ref.index >= plan.stops.length) {
+      throw new UserError(
+        `Plan "${plan.id}" has no stop ${ref.index}; indexes run from 0 to ${plan.stops.length - 1}`
+      );
+    }
+    return ref.index;
+  }
+  const want = lc(ref.label);
+  const byLabel = plan.stops.flatMap((s, i) => s.label && lc(s.label) === want ? [i] : []);
+  const byName = plan.stops.flatMap((s, i) => lc(stopName(s)) === want ? [i] : []);
+  const hits = byLabel.length ? byLabel : byName.length ? byName : plan.stops.flatMap((s, i) => namesOf(s).includes(want) ? [i] : []);
+  if (hits.length === 1) return hits[0];
+  if (hits.length > 1) {
+    throw new UserError(
+      `${hits.length} stops in plan "${plan.id}" match "${ref.label}"; give the index instead (${hits.join(", ")})`
+    );
+  }
+  const known = plan.stops.map((s, i) => `${i}: ${stopName(s)}`).join(", ");
+  throw new UserError(`No stop "${ref.label}" in plan "${plan.id}". Stops: ${known}`);
+}
+
 // src/plans/markdown.ts
 var box = {
   todo: "[ ]",
@@ -33065,6 +33815,7 @@ var box = {
   done: "[x]",
   skipped: "[-]"
 };
+var stopBox = { todo: "[ ]", done: "[x]", skipped: "[-]" };
 function planToMarkdown(plan) {
   const done = plan.items.filter((i) => i.status === "done" || i.status === "skipped").length;
   const out = [
@@ -33093,8 +33844,13 @@ function planToMarkdown(plan) {
   }
   if (plan.stops.length) {
     out.push("## Stops", "");
+    const next = nextStop(plan)?.index;
     plan.stops.forEach((s, n) => {
-      out.push(`${n + 1}. ${s.system}${s.station ? ` \u2014 ${s.station}` : ""}: ${s.purpose}`);
+      const place2 = [s.system, s.body, s.station].filter(Boolean).join(" \u2014 ");
+      const kind2 = s.kind ? `**${s.kind}** ` : "";
+      const mark = n === next ? " \u2190 next" : "";
+      out.push(`${n + 1}. ${stopBox[s.status]} ${kind2}${place2}: ${s.purpose}${mark}`);
+      if (s.notes) out.push(`   - Notes: ${s.notes}`);
     });
     out.push("");
   }
@@ -33112,63 +33868,8 @@ function planToMarkdown(plan) {
   return out.join("\n");
 }
 
-// src/plans/schema.ts
-var ItemKind = external_exports.enum([
-  "buy",
-  "engineer",
-  "experimental",
-  "unlock_engineer",
-  "gather",
-  "trade",
-  "refit"
-]);
-var ItemStatus = external_exports.enum(["todo", "in_progress", "done", "skipped"]);
-var PlanItemSchema = external_exports.object({
-  id: external_exports.string().min(1),
-  kind: ItemKind,
-  description: external_exports.string().min(1),
-  status: ItemStatus.default("todo"),
-  station: external_exports.string().optional(),
-  engineer: external_exports.string().optional(),
-  materials: external_exports.array(external_exports.object({ name: external_exports.string().min(1), count: external_exports.number().int().positive() })).optional(),
-  notes: external_exports.string().optional()
-});
-var StopKind = external_exports.enum(["shop", "trader", "engineer", "other"]);
-var StopSchema = external_exports.object({
-  system: external_exports.string().min(1),
-  station: external_exports.string().optional(),
-  purpose: external_exports.string().min(1),
-  label: external_exports.string().min(1).optional(),
-  kind: StopKind.optional(),
-  after: external_exports.array(external_exports.string().min(1)).optional()
-});
-var PlanRouteSchema = external_exports.object({
-  computed_at: external_exports.string(),
-  from: external_exports.string(),
-  stops: external_exports.array(external_exports.string()),
-  total_min: external_exports.number(),
-  plotted: external_exports.boolean()
-});
-var PlanInputSchema = external_exports.object({
-  id: external_exports.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/, "id must be lowercase letters, digits and dashes"),
-  name: external_exports.string().min(1),
-  target_build: external_exports.unknown().optional(),
-  items: external_exports.array(PlanItemSchema).default([]),
-  stops: external_exports.array(StopSchema).default([]),
-  route: PlanRouteSchema.optional(),
-  notes: external_exports.string().optional()
-});
-var PlanSchema = PlanInputSchema.extend({
-  created_at: external_exports.string(),
-  updated_at: external_exports.string()
-});
-var PlanFileSchema = external_exports.object({
-  version: external_exports.literal(1),
-  plans: external_exports.array(PlanSchema)
-});
-
 // src/plans/store.ts
-var LOCK_TIMEOUT_MS = 5e3;
+var LOCK_TIMEOUT_MS2 = 5e3;
 var PlanExistsError = class extends UserError {
   constructor(id) {
     super(`Plan ${id} exists; pass overwrite: true to replace it`);
@@ -33178,7 +33879,7 @@ var PlanStore = class {
   constructor(file2, now = () => /* @__PURE__ */ new Date(), opts = {}) {
     this.file = file2;
     this.now = now;
-    this.lockTimeoutMs = opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS;
+    this.lockTimeoutMs = opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS2;
     this.lockDir = opts.lockDir;
     this.guard = opts.guard;
     this.markdownDir = opts.markdownDir;
@@ -33198,6 +33899,7 @@ var PlanStore = class {
       name: p.name,
       items: p.items.length,
       done: p.items.filter((i) => i.status === "done" || i.status === "skipped").length,
+      next_stop: nextStop(p),
       updated_at: p.updated_at
     }));
   }
@@ -33215,11 +33917,16 @@ var PlanStore = class {
       if (idx >= 0 && opts.overwrite === false) {
         throw new PlanExistsError(parsed.data.id);
       }
-      const plan = {
+      const old = idx >= 0 ? data.plans[idx] : void 0;
+      const plan = cleanRoute({
         ...parsed.data,
-        created_at: idx >= 0 ? data.plans[idx].created_at : stamp,
+        created_at: old ? old.created_at : stamp,
         updated_at: stamp
-      };
+      });
+      const route = plan.route;
+      if (route?.stop_indexes && old?.route?.computed_at === route.computed_at && !sameStops(old.stops, plan.stops)) {
+        delete route.stop_indexes;
+      }
       if (idx >= 0) data.plans[idx] = plan;
       else data.plans.push(plan);
       return plan;
@@ -33237,10 +33944,30 @@ var PlanStore = class {
       return plan;
     });
   }
-  setRoute(planId, route) {
+  updateStop(planId, ref, patch) {
+    return this.mutate((data) => {
+      const plan = data.plans.find((p) => p.id === planId);
+      if (!plan) throw new UserError(`Plan "${planId}" not found`);
+      const stop = plan.stops[findStop(plan, ref)];
+      if (patch.status !== void 0) stop.status = patch.status;
+      if (patch.notes !== void 0) stop.notes = patch.notes;
+      plan.updated_at = this.now().toISOString();
+      return plan;
+    });
+  }
+  /**
+   * Saves a computed route. With `stops`, the stops the route was computed from, it refuses when
+   * the plan's stops have changed since, because the route's stop_indexes would point at others.
+   */
+  setRoute(planId, route, opts = {}) {
     return this.mutate((data) => {
       const plan = data.plans.find((p) => p.id === planId);
       if (!plan) throw new UserError(`Plan "${planId}" not found`);
+      if (opts.stops && !sameStops(opts.stops, plan.stops)) {
+        throw new UserError(
+          `The stops of plan "${planId}" changed while the route was computed; run route_stops again to save it`
+        );
+      }
       plan.route = route;
       plan.updated_at = this.now().toISOString();
       return plan;
@@ -33271,6 +33998,7 @@ var PlanStore = class {
     if (!parsed.success) {
       throw new UserError(`Plan file ${this.file} is invalid: ${external_exports.prettifyError(parsed.error)}`);
     }
+    parsed.data.plans.forEach(cleanRoute);
     return parsed.data;
   }
   // Read-modify-write runs one at a time so concurrent tool calls cannot lose updates.
@@ -33322,7 +34050,7 @@ var PlanStore = class {
     if (!dir) return null;
     let st;
     try {
-      st = await lstat2(dir);
+      st = await lstat3(dir);
     } catch {
       return null;
     }
@@ -33335,7 +34063,7 @@ var PlanStore = class {
   async writeMarkdown(data, before) {
     const dir = this.markdownDir;
     try {
-      await mkdir3(dir, { recursive: true });
+      await mkdir4(dir, { recursive: true });
       const problem = await this.directoryProblem();
       if (problem) {
         console.error(problem);
@@ -33358,7 +34086,7 @@ var PlanStore = class {
         const n = `${id}.md`;
         if (keep.has(n) || !PRUNABLE.test(n)) continue;
         const file2 = path8.join(dir, n);
-        const st = await lstat2(file2).catch(() => null);
+        const st = await lstat3(file2).catch(() => null);
         if (st?.isFile()) await rm(file2, { force: true });
       }
       this.lastCopyError = null;
@@ -33368,6 +34096,20 @@ var PlanStore = class {
     }
   }
 };
+function cleanRoute(plan) {
+  const route = plan.route;
+  if (!route?.stop_indexes) return plan;
+  if (route.stop_indexes.length !== route.stops.length) {
+    delete route.stop_indexes;
+  } else {
+    route.stop_indexes = route.stop_indexes.map((e) => e.filter((i) => i < plan.stops.length));
+  }
+  return plan;
+}
+var stopKey = (s) => JSON.stringify([s.system, s.station, s.body, s.label, s.purpose]);
+function sameStops(a, b) {
+  return a.length === b.length && a.every((s, i) => stopKey(s) === stopKey(b[i]));
+}
 var PRUNABLE = /^[a-z0-9][a-z0-9-]{0,63}\.md$/;
 
 // src/prefs/schema.ts
@@ -33490,11 +34232,11 @@ function applyPatch(base2, patch) {
 }
 
 // src/prefs/store.ts
-var LOCK_TIMEOUT_MS2 = 5e3;
+var LOCK_TIMEOUT_MS3 = 5e3;
 var PreferencesStore = class {
   constructor(file2, opts = {}) {
     this.file = file2;
-    this.lockTimeoutMs = opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS2;
+    this.lockTimeoutMs = opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS3;
     this.lockDir = opts.lockDir;
     this.guard = opts.guard;
   }
@@ -33555,7 +34297,7 @@ var PreferencesStore = class {
 };
 
 // src/ships/data.ts
-import { mkdir as mkdir4, readFile as readFile5, rename as rename4, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile5, rename as rename4, writeFile as writeFile4 } from "fs/promises";
 import path9 from "path";
 import { gunzipSync } from "zlib";
 
@@ -33757,7 +34499,7 @@ var ships_default = {
 
 // src/ships/tar.ts
 var BLOCK = 512;
-function str3(buf, start, len) {
+function str4(buf, start, len) {
   const field = buf.subarray(start, start + len);
   const end = field.indexOf(0);
   return field.subarray(0, end < 0 ? len : end).toString("utf8");
@@ -33785,7 +34527,7 @@ function readTar(buf) {
   while (pos + BLOCK <= buf.length) {
     const h = buf.subarray(pos, pos + BLOCK);
     if (h.every((b) => b === 0)) break;
-    const size = Number.parseInt(str3(h, 124, 12).trim() || "0", 8);
+    const size = Number.parseInt(str4(h, 124, 12).trim() || "0", 8);
     const type = String.fromCharCode(h[156] ?? 0);
     const start = pos + BLOCK;
     if (start + size > buf.length) throw new Error("Truncated tar archive");
@@ -33799,9 +34541,9 @@ function readTar(buf) {
       comment = paxFields(data).comment ?? comment;
       continue;
     }
-    let path15 = str3(h, 0, 100);
-    if (str3(h, 257, 6) === "ustar") {
-      const prefix = str3(h, 345, 155);
+    let path15 = str4(h, 0, 100);
+    if (str4(h, 257, 6) === "ustar") {
+      const prefix = str4(h, 345, 155);
       if (prefix) path15 = `${prefix}/${path15}`;
     }
     if (nextPath !== null) path15 = nextPath;
@@ -34083,7 +34825,7 @@ var ShipDataService = class {
     }
   }
   async save(snapshot) {
-    await mkdir4(path9.dirname(this.file), { recursive: true });
+    await mkdir5(path9.dirname(this.file), { recursive: true });
     const tmp = `${this.file}.${process.pid}.tmp`;
     await writeFile4(tmp, JSON.stringify(snapshot));
     await rename4(tmp, this.file);
@@ -34092,7 +34834,7 @@ var ShipDataService = class {
 var message = (err) => err instanceof Error ? err.message : String(err);
 
 // src/settings/secrets.ts
-import { lstat as lstat3, mkdir as mkdir5, rm as rm2 } from "fs/promises";
+import { lstat as lstat4, mkdir as mkdir6, rm as rm2 } from "fs/promises";
 import path10 from "path";
 
 // src/settings/crypto.ts
@@ -34195,7 +34937,7 @@ var SecretsSchema = external_exports.strictObject({
 });
 var WrongPasswordError = class extends SecretsError {
 };
-var LOCK_TIMEOUT_MS3 = 5e3;
+var LOCK_TIMEOUT_MS4 = 5e3;
 var SecretStore = class _SecretStore {
   constructor(file2, opts = {}) {
     this.file = file2;
@@ -34229,7 +34971,7 @@ var SecretStore = class _SecretStore {
       await lockedWrite(
         this.file,
         {
-          timeoutMs: this.opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS3,
+          timeoutMs: this.opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS4,
           lockedMessage: "Secrets file is locked by another process; try again",
           lockDir: this.opts.lockDir,
           mode: 384
@@ -34258,11 +35000,11 @@ var SecretStore = class _SecretStore {
   reset() {
     const run = this.queue.then(async () => {
       await this.opts.guard?.();
-      await mkdir5(path10.dirname(this.file), { recursive: true });
-      if (this.opts.lockDir) await mkdir5(this.opts.lockDir, { recursive: true });
+      await mkdir6(path10.dirname(this.file), { recursive: true });
+      if (this.opts.lockDir) await mkdir6(this.opts.lockDir, { recursive: true });
       const release = await acquireLock(
         this.file,
-        this.opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS3,
+        this.opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS4,
         "Secrets file is locked by another process; try again",
         this.opts.lockDir
       );
@@ -34298,7 +35040,7 @@ var SecretStore = class _SecretStore {
   async checkFile() {
     let st;
     try {
-      st = await lstat3(this.file);
+      st = await lstat4(this.file);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return null;
@@ -34356,7 +35098,7 @@ var SecretStore = class _SecretStore {
     return lockedWrite(
       this.file,
       {
-        timeoutMs: this.opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS3,
+        timeoutMs: this.opts.lockTimeoutMs ?? LOCK_TIMEOUT_MS4,
         lockedMessage: "Secrets file is locked by another process; try again",
         lockDir: this.opts.lockDir,
         mode: 384
@@ -34834,7 +35576,7 @@ function buildDeps(config2, opts = {}) {
     markdownDir: config2.plansMarkdownDir
   });
   const legacyPlans = config2.legacyPlansEnv ? `ED_MCP_PLANS is no longer used. Plans are now in ${config2.plansFile}. Move your old plans file there, or use plan_import, then remove ED_MCP_PLANS.` : void 0;
-  const syncWarnings = sync ? () => sync.warnings([config2.plansFile, config2.prefsFile, config2.secretsFile]) : void 0;
+  const syncWarnings = sync ? () => sync.warnings([config2.plansFile, config2.prefsFile, config2.activityFile, config2.secretsFile]) : void 0;
   const inaraCache = new TtlCache("inara", 6e4);
   caches.register(inaraCache);
   const inara = new InaraClient(http, () => settings.inara(), inaraCache);
@@ -34849,10 +35591,13 @@ function buildDeps(config2, opts = {}) {
   caches.register(spanshMarketCache);
   const spanshSweepCache = new SweepCache();
   caches.register(spanshSweepCache);
+  const spanshWarCache = new TtlCache("spansh-wars", 6e5);
+  caches.register(spanshWarCache);
   const spansh = new SpanshClient(http, spanshCache, {
     systemCache: spanshSystemCache,
     marketCache: spanshMarketCache,
-    sweepCache: spanshSweepCache
+    sweepCache: spanshSweepCache,
+    warCache: spanshWarCache
   });
   const capiHttp = new HttpClient({ userAgent: `EDCD-EdMcp-${VERSION}`, fetchFn: opts.fetchFn });
   const capiCache = new TtlCache("capi", 6e4);
@@ -34898,6 +35643,10 @@ function buildDeps(config2, opts = {}) {
       lockDir: lockFor(config2.prefsFile),
       guard: guardFor(config2.prefsFile)
     }),
+    activity: new ActivityStore(config2.activityFile, void 0, {
+      lockDir: lockFor(config2.activityFile),
+      guard: guardFor(config2.activityFile)
+    }),
     sync,
     syncWarnings,
     versionCheck: new VersionCheck({ http, cacheDir: config2.cacheDir, current: VERSION }),
@@ -42950,6 +43699,124 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
+// src/tools/result.ts
+function ok(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value) }] };
+}
+function fail(message2) {
+  return { isError: true, content: [{ type: "text", text: message2 }] };
+}
+function wrap(fn) {
+  return async (args) => {
+    try {
+      return ok(await fn(args));
+    } catch (err) {
+      if (err instanceof UserError) return fail(err.message);
+      console.error(err);
+      return fail(`Internal error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  };
+}
+function wrapWarn(fn, warnings) {
+  const inner = wrap(fn);
+  return async (args) => {
+    const result = await inner(args);
+    const list2 = warnings ? await warnings().catch(() => []) : [];
+    if (!list2.length) return result;
+    return {
+      ...result,
+      content: [
+        ...result.content,
+        { type: "text", text: `Warnings:
+${list2.map((w) => `- ${w}`).join("\n")}` }
+      ]
+    };
+  };
+}
+function reason(err) {
+  if (err instanceof UserError) return err.message;
+  console.error(err);
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/tools/activity.ts
+var NO_NOTE = "No activity is saved. Ask the player what they are doing, then save it.";
+function registerActivityTools(server, deps) {
+  const now = deps.now ?? Date.now;
+  const location = async () => {
+    if (!deps.journal) return { location: null, location_note: "The journal is not available." };
+    try {
+      const s = await deps.journal.state();
+      return {
+        location: {
+          system: s.location.system,
+          station: s.location.station,
+          docked: s.location.docked,
+          as_of: s.as_of,
+          age_minutes: s.age_minutes,
+          warnings: s.warnings
+        }
+      };
+    } catch (err) {
+      return { location: null, location_note: `The journal could not be read: ${reason(err)}` };
+    }
+  };
+  server.registerTool(
+    "activity_get",
+    {
+      annotations: {
+        title: "Get Activity",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      description: "What the commander was last doing: a short saved note (kind, summary, optional plan_id), its age, and the commander's current location from the journal. Call it at the start of a conversation. When the location or age says the player has moved on, ask before relying on the note."
+    },
+    wrapWarn(async () => {
+      const [activity, here] = await Promise.all([deps.activity.get(), location()]);
+      if (!activity) return { activity: null, note: NO_NOTE, ...here };
+      const saved = Date.parse(activity.updated_at);
+      const age = Number.isNaN(saved) ? null : Math.max(0, Math.round((now() - saved) / 6e4));
+      return { activity, age_minutes: age, ...here };
+    }, deps.warnings)
+  );
+  server.registerTool(
+    "activity_set",
+    {
+      annotations: {
+        title: "Set Activity",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      description: `Replace the saved note of what the commander is doing, so the next conversation can pick it up. kind and summary (at most ${MAX_SUMMARY} characters: where, the goal, and progress) are required; plan_id names the active route or build plan. Update it when the player starts something new or the goal changes. clear: true deletes the note.`,
+      inputSchema: {
+        kind: ActivityKind.optional(),
+        summary: external_exports.string().max(MAX_SUMMARY).optional(),
+        plan_id: PlanId.optional(),
+        clear: external_exports.boolean().optional()
+      }
+    },
+    wrapWarn(
+      async (a) => {
+        if (a.clear) {
+          if (a.kind !== void 0 || a.summary !== void 0 || a.plan_id !== void 0) {
+            throw new UserError("Give clear: true alone, or kind and summary without clear");
+          }
+          return { cleared: await deps.activity.clear() };
+        }
+        if (a.kind === void 0 || a.summary === void 0) {
+          throw new UserError("Give kind and summary, or clear: true");
+        }
+        return deps.activity.set({ kind: a.kind, summary: a.summary, plan_id: a.plan_id });
+      },
+      deps.warnings
+    )
+  );
+}
+
 // src/ships/constants.ts
 var MODULE_GROUP_NAMES = {
   pp: "Power Plant",
@@ -43686,8 +44553,8 @@ var family = (symbol2) => (symbol2 ?? "").toLowerCase().replace(/size\d+|class\d
 function pick2(candidates, current) {
   let list2 = candidates;
   if (current?.module.symbol) {
-    const same4 = list2.filter((m) => family(m.symbol) === family(current.module.symbol));
-    if (same4.length) list2 = same4;
+    const same6 = list2.filter((m) => family(m.symbol) === family(current.module.symbol));
+    if (same6.length) list2 = same6;
   }
   const plain = list2.filter((m) => m.name === void 0 && m.preEngineered === void 0);
   return (plain.length ? plain : list2)[0] ?? null;
@@ -43912,8 +44779,8 @@ function toSlef(build) {
 
 // src/ships/calc/core.ts
 var CARGO_HATCH_MW = 0.6;
-var num3 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
-var prop = (b, name) => num3(b.ship.properties[name]);
+var num4 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var prop = (b, name) => num4(b.ship.properties[name]);
 var find = (b, grp) => b.modules.find((m) => m.module.grp === grp) ?? null;
 function scale(m, feature) {
   const v = m.engineering?.modifiers[feature];
@@ -43922,17 +44789,17 @@ function scale(m, feature) {
 function moduleStat(m, feature) {
   const mods = m.engineering?.modifiers ?? {};
   if ((feature === "minmass" || feature === "maxmass") && mods[feature] === void 0) {
-    const base2 = num3(m.module[feature]);
+    const base2 = num4(m.module[feature]);
     const optmass = scale(m, "optmass");
     if (SHIELD_GENERATORS.has(m.module.grp) && feature === "maxmass" && optmass < 1) return base2;
     return base2 * optmass;
   }
   const mul = /^(min|opt|max)mul(.*)$/.exec(feature);
   if (mul) {
-    const base2 = num3(m.module[feature]) || num3(m.module[`${mul[1]}mul`]);
+    const base2 = num4(m.module[feature]) || num4(m.module[`${mul[1]}mul`]);
     return base2 * scale(m, "optmul");
   }
-  return num3(modifiedValue(m.module, mods, feature));
+  return num4(modifiedValue(m.module, mods, feature));
 }
 var sum = (b, feature, round2 = (v) => v) => b.modules.reduce((s, m) => s + round2(moduleStat(m, feature)), 0);
 function massFuel(b) {
@@ -44069,8 +44936,8 @@ var BROKEN_DELAY_S = 16;
 var HRPS = /* @__PURE__ */ new Set(["hr", "ghrp", "mahr"]);
 var MRPS = /* @__PURE__ */ new Set(["mrp", "gmrp"]);
 var RESISTANCES = { explosive: "explres", kinetic: "kinres", thermal: "thermres" };
-var num4 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
-var prop2 = (b, name) => num4(b.ship.properties[name]);
+var num5 = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+var prop2 = (b, name) => num5(b.ship.properties[name]);
 var active = (b, grps) => b.modules.filter((m) => grps.has(m.module.grp) && online(b, m));
 function pipRecharge(rate, pips) {
   return rate * Math.pow(pips / 4, 1.1);
@@ -44244,46 +45111,6 @@ function weapons(b) {
   };
 }
 
-// src/tools/result.ts
-function ok(value) {
-  return { content: [{ type: "text", text: JSON.stringify(value) }] };
-}
-function fail(message2) {
-  return { isError: true, content: [{ type: "text", text: message2 }] };
-}
-function wrap(fn) {
-  return async (args) => {
-    try {
-      return ok(await fn(args));
-    } catch (err) {
-      if (err instanceof UserError) return fail(err.message);
-      console.error(err);
-      return fail(`Internal error: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  };
-}
-function wrapWarn(fn, warnings) {
-  const inner = wrap(fn);
-  return async (args) => {
-    const result = await inner(args);
-    const list2 = warnings ? await warnings().catch(() => []) : [];
-    if (!list2.length) return result;
-    return {
-      ...result,
-      content: [
-        ...result.content,
-        { type: "text", text: `Warnings:
-${list2.map((w) => `- ${w}`).join("\n")}` }
-      ]
-    };
-  };
-}
-function reason(err) {
-  if (err instanceof UserError) return err.message;
-  console.error(err);
-  return err instanceof Error ? err.message : String(err);
-}
-
 // src/tools/build.ts
 var SCO_NOTE = "Jump range uses the drive's normal values, not supercruise overcharge.";
 var SlefInput = external_exports.union([external_exports.string(), external_exports.array(external_exports.unknown()), external_exports.record(external_exports.string(), external_exports.unknown())]);
@@ -45502,7 +46329,7 @@ async function locate(deps) {
 // src/routes/legs.ts
 var STATION_LIMIT = 500;
 var PLANETARY = /planetary|surface|settlement/i;
-var same = (a, b) => a !== null && b !== null && a.toLowerCase() === b.toLowerCase();
+var same3 = (a, b) => a !== null && b !== null && a.toLowerCase() === b.toLowerCase();
 function createPlacer(spansh, notes) {
   const systems = /* @__PURE__ */ new Map();
   const lookup2 = (name) => {
@@ -45514,7 +46341,7 @@ function createPlacer(spansh, notes) {
   return {
     async place(system, station) {
       const info = await lookup2(system);
-      const hit = station ? info.stations.find((s) => same(s.name, station)) : void 0;
+      const hit = station ? info.stations.find((s) => same3(s.name, station)) : void 0;
       if (station && !hit) {
         notes.add(`Station ${station} not found in ${info.name}; assumed 1000 ls from arrival.`);
       }
@@ -45528,7 +46355,7 @@ function createPlacer(spansh, notes) {
     },
     async placeEngineer(e) {
       const info = await lookup2(e.system);
-      const hit = info.stations.find((s) => same(s.name, e.base));
+      const hit = info.stations.find((s) => same3(s.name, e.base));
       if (!hit) {
         notes.add(
           `${e.name}'s base ${e.base} is not in Spansh; assumed a planetary base 1000 ls from arrival.`
@@ -45545,10 +46372,10 @@ function createPlacer(spansh, notes) {
   };
 }
 function legBetween(from, to, travel) {
-  if (same(from.system, to.system) && same(from.station, to.station)) {
+  if (same3(from.system, to.system) && same3(from.station, to.station)) {
     return { jumps: 0, seconds: 0, distanceLy: 0 };
   }
-  const distanceLy2 = same(from.system, to.system) ? 0 : Math.hypot(
+  const distanceLy2 = same3(from.system, to.system) ? 0 : Math.hypot(
     from.coords.x - to.coords.x,
     from.coords.y - to.coords.y,
     from.coords.z - to.coords.z
@@ -45935,6 +46762,13 @@ function registerMissionTools(server, deps) {
 // src/tools/journal.ts
 var FRESHNESS_TEXT = "as_of is the time of the newest journal event and age_minutes its age; warnings flag stale data (over 30 minutes old) and unreadable journal files.";
 var NAMES_MISSING = 'Material names are not available until the game data catalog is downloaded. Call any catalog tool (for example catalog_material) or cache_refresh with source "catalog".';
+var MASSACRE_NOTE = "Kill counts are an estimate from the journal. Kills by wing mates, kills before a mission was accepted elsewhere and the game's own rules can differ; the mission panel in the game is authoritative.";
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
 var freshness = (s) => ({
   as_of: s.as_of,
   age_minutes: s.age_minutes,
@@ -46054,7 +46888,104 @@ function registerJournalTools(server, deps) {
       return { engineers: s.engineers, ...freshness(s) };
     })
   );
+  server.registerTool(
+    "journal_exobiology",
+    {
+      annotations: { title: "Journal Exobiology", ...READ_ONLY },
+      description: 'Exobiology progress in a system from the local game journal (last 14 days). For each body with biological signals: bio_signals (the count from the FSS or surface scan), genera found by the surface scan, each species sampled with samples taken (stage 0/3 to 3/3, analysed once complete; abandoned when another species was started first, which drops an unfinished sample, or after a death), and not_started genera with no sample yet. unsold_analysed counts species analysed since the last sale of organic data (or death), in any system. The journal has no sample positions. system defaults to the current system; body is a full body name or the part after the system name, such as "A 4". ' + FRESHNESS_TEXT,
+      inputSchema: {
+        system: external_exports.string().optional().describe("System name; default the current system"),
+        body: external_exports.string().optional().describe('Body name, or the part after the system ("A 4")')
+      }
+    },
+    wrap(async (a) => {
+      const s = await deps.journal.state();
+      const system = systemOf(a.system, s.location.system);
+      const address = systemAddress(s.events, system);
+      const r = exobiology(s.events, address ?? -1, { system, body: a.body });
+      return {
+        system,
+        ...r,
+        ...address === null ? { note: notVisited(system) } : {},
+        ...freshness(s)
+      };
+    })
+  );
+  server.registerTool(
+    "journal_exploration",
+    {
+      annotations: { title: "Journal Exploration", ...READ_ONLY },
+      description: "Exploration scans of a system from the local game journal (last 14 days). discovery has the FSS discovery scan body count and progress, and all_bodies_found once the FSS is complete. bodies lists each scanned body, nearest first: type, distance_ls from the arrival star, landable, terraformable, atmosphere, rings, was_discovered and was_mapped (by someone before you), mapped_by_you (surface scan complete) and signals. Values are not estimated. system defaults to the current system. " + FRESHNESS_TEXT,
+      inputSchema: {
+        system: external_exports.string().optional().describe("System name; default the current system")
+      }
+    },
+    wrap(async (a) => {
+      const s = await deps.journal.state();
+      const system = systemOf(a.system, s.location.system);
+      const address = systemAddress(s.events, system);
+      return {
+        system,
+        ...exploration(s.events, address ?? -1),
+        ...address === null ? { note: notVisited(system) } : {},
+        ...freshness(s)
+      };
+    })
+  );
+  server.registerTool(
+    "journal_massacre",
+    {
+      annotations: { title: "Journal Massacre Progress", ...READ_ONLY },
+      description: "Progress of active massacre missions from the local game journal, grouped by target faction and then by giving faction. Each mission has kills_required, kills_counted (from bounties and combat bonds against the target since it was accepted) and kills_left. A kill counts toward the oldest open mission of each giving faction, as the game stacks them; a mission redirected back to its giver is done. A target's kills_left is the most any one giver still needs. The counts are an estimate. uncounted lists massacre missions accepted before the 14-day journal window. " + FRESHNESS_TEXT
+    },
+    wrap(async () => {
+      const s = await deps.journal.state();
+      const r = massacre(s.missions, s.events);
+      return {
+        targets: r.groups,
+        uncounted: r.uncounted.map((m) => ({ id: m.id, name: m.name, expires: m.expires })),
+        note: MASSACRE_NOTE,
+        ...freshness(s)
+      };
+    })
+  );
+  server.registerTool(
+    "journal_events",
+    {
+      annotations: { title: "Journal Events", ...READ_ONLY },
+      description: "Raw events from the local game journal (last 14 days), newest first, as the game wrote them. Use it for anything the other journal tools do not cover, instead of reading the journal files. events limits the event names (for example Bounty or Docked); since is an ISO time; system keeps events in that system. limit defaults to 50 (at most 200). Arrays longer than 20 entries are cut, with a last entry that says how many were left out. " + FRESHNESS_TEXT,
+      inputSchema: {
+        events: external_exports.array(external_exports.string()).optional().describe("Event names, such as Bounty or Docked"),
+        since: external_exports.string().optional().describe("Only events at or after this ISO time"),
+        system: external_exports.string().optional().describe("Only events in this system"),
+        limit: external_exports.number().int().min(1).max(200).default(50)
+      }
+    },
+    wrap(async (a) => {
+      const since = a.since === void 0 ? void 0 : Date.parse(a.since);
+      if (since !== void 0 && Number.isNaN(since)) {
+        throw new UserError(`since is not a time: ${a.since}. Use an ISO time.`);
+      }
+      const s = await deps.journal.state();
+      const r = await deps.journal.recentEvents(
+        { events: a.events, since, system: a.system },
+        a.limit
+      );
+      return {
+        events: r.events.map(truncate),
+        ...freshness({ ...s, warnings: [...s.warnings, ...r.warnings] })
+      };
+    })
+  );
 }
+function systemOf(given, current) {
+  const system = given?.trim() || current;
+  if (!system) {
+    throw new UserError("The journal has no current system. Give a system name.");
+  }
+  return system;
+}
+var notVisited = (system) => `The journal has no events in ${system} in the last 14 days. Check the system name.`;
 
 // src/trade/loops.ts
 function bestCargo(from, to, cargo, capital) {
@@ -46211,7 +47142,7 @@ var NO_LOOPS = "No profitable loop found. Try a larger radius, another centre, o
 var PERMIT_SPARES = 30;
 var PERMIT_EXTRA_MS = 8e3;
 var Station = external_exports.object({ system: external_exports.string(), station: external_exports.string() });
-var same2 = (a, b) => a.toLowerCase() === b.toLowerCase();
+var same4 = (a, b) => a.toLowerCase() === b.toLowerCase();
 var tenth = (n) => Math.round(n * 10) / 10;
 var minutes = (seconds) => tenth(seconds / 60);
 var placeOf = (s) => ({
@@ -46416,11 +47347,11 @@ function registerLoopTools(server, deps) {
         if (here) {
           const name = centre.station;
           let startMarket = found.stations.find(
-            (st) => same2(st.name, name) && same2(st.system, centre.system)
+            (st) => same4(st.name, name) && same4(st.system, centre.system)
           );
           if (!startMarket) {
             const info = await spansh.system(centre.system, STATION_LIMIT);
-            const entry2 = info.stations.find((st) => same2(st.name, name));
+            const entry2 = info.stations.find((st) => same4(st.name, name));
             if (entry2?.market_id == null) {
               throw new UserError(`Spansh has no market for ${name} in ${info.name}.`);
             }
@@ -46609,7 +47540,7 @@ function registerLoopTools(server, deps) {
   );
   async function includeMarket(inc) {
     const info = await spansh.system(inc.system, STATION_LIMIT);
-    const id = info.stations.find((st) => same2(st.name, inc.station))?.market_id;
+    const id = info.stations.find((st) => same4(st.name, inc.station))?.market_id;
     if (id == null) return null;
     return spansh.stationMarket(id).catch((err) => {
       if (err instanceof UserError) return null;
@@ -46618,6 +47549,116 @@ function registerLoopTools(server, deps) {
   }
 }
 
+// src/systems/groundcz.ts
+var AT_WAR = /* @__PURE__ */ new Set(["war", "civil war"]);
+var FRONTLINE = "Frontline Solutions";
+var PAD_RANK2 = { S: 1, M: 2, L: 3 };
+var padOk2 = (pad, min3) => !min3 || (PAD_RANK2[pad ?? ""] ?? 0) >= PAD_RANK2[min3];
+var smallestGap = (s) => s.settlements[0]?.gap_ls ?? Infinity;
+function groundCzTargets(systems, centre, opts) {
+  const leftOut = { stale: 0, no_warring_settlements: 0, no_station_near: 0, pad_too_small: 0 };
+  const targets = [];
+  for (const system of systems) {
+    const updated = system.updated_at ? Date.parse(system.updated_at) : NaN;
+    const ageHours2 = Number.isNaN(updated) ? Infinity : (opts.now - updated) / 36e5;
+    if (ageHours2 > opts.maxAgeHours) {
+      leftOut.stale++;
+      continue;
+    }
+    const warring = system.factions.flatMap((f) => {
+      const state = f.active_states.find((s) => AT_WAR.has(s.toLowerCase()));
+      return state ? [{ name: f.name, state }] : [];
+    });
+    const sides = new Set(warring.map((w) => w.name));
+    const settlements = system.stations.filter(
+      (s) => s.type === "Settlement" && s.owner !== null && sides.has(s.owner) && s.arrival_ls !== null
+    );
+    if (!settlements.length) {
+      leftOut.no_warring_settlements++;
+      continue;
+    }
+    const warringSettlements = {};
+    for (const s of settlements)
+      warringSettlements[s.owner] = (warringSettlements[s.owner] ?? 0) + 1;
+    const stations = system.stations.filter((s) => s.services.includes(FRONTLINE) && s.arrival_ls !== null).map((s) => {
+      const planetary = PLANETARY.test(s.type ?? "");
+      const near = settlements.map((x) => ({
+        name: x.name,
+        owner: x.owner,
+        arrival_ls: x.arrival_ls,
+        gap_ls: Math.abs(x.arrival_ls - s.arrival_ls)
+      })).filter((x) => x.gap_ls <= opts.maxGapLs).sort((a, b) => a.gap_ls - b.gap_ls);
+      return {
+        name: s.name,
+        type: s.type,
+        pad: s.pad,
+        arrival_ls: s.arrival_ls,
+        planetary,
+        dock_s: opts.dockSeconds(s.arrival_ls, planetary),
+        settlements: near
+      };
+    }).filter((s) => s.settlements.length > 0);
+    const fit = stations.filter((s) => padOk2(s.pad, opts.minPad)).sort(
+      (a, b) => a.dock_s - b.dock_s || b.settlements.length - a.settlements.length || smallestGap(a) - smallestGap(b)
+    );
+    if (!stations.length) {
+      leftOut.no_station_near++;
+      continue;
+    }
+    if (!fit.length) {
+      leftOut.pad_too_small++;
+      continue;
+    }
+    targets.push({
+      system,
+      distanceLy: distanceLy(system.coords, centre),
+      ageHours: ageHours2,
+      warring,
+      best: fit[0],
+      others: fit.slice(1),
+      warringSettlements
+    });
+  }
+  targets.sort(
+    (a, b) => Math.floor(a.ageHours) - Math.floor(b.ageHours) || b.best.settlements.length - a.best.settlements.length || smallestGap(a.best) - smallestGap(b.best) || a.distanceLy - b.distanceLy
+  );
+  return { targets, leftOut };
+}
+var isStar = (b) => /Star$/.test(b.subType ?? "");
+function czDetail(best, bodies, maxGapLs) {
+  const bodyOf = (station) => bodies.find((b) => b.stations.includes(station)) ?? null;
+  const settlementBodies = {};
+  for (const s of best.settlements) {
+    const b = bodyOf(s.name);
+    if (b) settlementBodies[s.name] = b.name;
+  }
+  const counts2 = /* @__PURE__ */ new Map();
+  for (const name of Object.values(settlementBodies)) counts2.set(name, (counts2.get(name) ?? 0) + 1);
+  const body_family = bodies.filter((b) => counts2.has(b.name)).map((b) => ({ name: b.name, subType: b.subType, settlements: counts2.get(b.name) }));
+  const onBody = (b) => !!b && counts2.has(b.name);
+  if (best.planetary) {
+    const own2 = bodyOf(best.name);
+    return {
+      drop: onBody(own2) ? "same_body" : "gap_only",
+      near_body: own2?.name ?? null,
+      settlementBodies,
+      body_family
+    };
+  }
+  const near = bodies.filter((b) => !isStar(b) && Math.abs(b.arrival_ls - best.arrival_ls) <= maxGapLs).sort(
+    (a, b) => Math.abs(a.arrival_ls - best.arrival_ls) - Math.abs(b.arrival_ls - best.arrival_ls)
+  )[0];
+  if (!near) return { drop: "gap_only", near_body: null, settlementBodies, body_family };
+  const root = near.parentPlanetId ?? near.bodyId;
+  const family2 = bodies.filter((b) => b.bodyId === root || b.parentPlanetId === root);
+  return {
+    drop: family2.some(onBody) ? "orbital" : "gap_only",
+    near_body: near.name,
+    settlementBodies,
+    body_family
+  };
+}
+
 // src/systems/massacre.ts
 var SOURCE_RANGE_LY = 10;
 var NO_MASSACRES = /* @__PURE__ */ new Set(["war", "civil war", "election"]);
@@ -46726,6 +47767,7 @@ function systemsByState(systems, centre, radiusLy, q) {
 // src/tools/systems.ts
 var TIME_LIMIT_MS2 = 2e4;
 var MASSACRE_MARGIN_LY = 2 * SOURCE_RANGE_LY;
+var partialNote = (coveredLy) => `Spansh returned systems out to ${Math.floor(coveredLy * 10) / 10} ly within the time limit. Call again to continue the search.`;
 var STALE_HOURS = 72;
 var FAR_STAR_LS = 1e3;
 var Radius = external_exports.number().min(1).max(50).default(50);
@@ -46809,12 +47851,17 @@ function registerSystemTools(server, deps) {
         const sweep = await deps.spansh.populatedSystems(near, a.radius_ly, {
           deadline: now() + TIME_LIMIT_MS2
         });
-        const matches2 = systemsByState(sweep.systems, sweep.centre, a.radius_ly, q);
+        const matches2 = systemsByState(
+          sweep.systems,
+          sweep.centre,
+          Math.min(a.radius_ly, sweep.coveredLy),
+          q
+        );
         const shown = matches2.slice(0, a.limit);
         const stale = shown.filter((m) => (ageHours2(m.system) ?? 0) > STALE_HOURS).length;
         if (stale) notes.push(`${stale} results have data more than ${STALE_HOURS / 24} days old.`);
         if (sweep.partial) {
-          notes.push("Spansh did not return every system in time; results may be missing.");
+          notes.push(partialNote(sweep.coveredLy));
         }
         return {
           near,
@@ -46822,6 +47869,7 @@ function registerSystemTools(server, deps) {
           travel: describeRules(rules).travel,
           total_matches: matches2.length,
           partial: sweep.partial,
+          ...sweep.partial ? { covered_ly: Math.floor(sweep.coveredLy * 10) / 10 } : {},
           systems: shown.map((m) => {
             const s = m.system;
             const war = m.factions.some(
@@ -46886,7 +47934,9 @@ function registerSystemTools(server, deps) {
           deadline: now() + TIME_LIMIT_MS2
         });
         const { targets, leftOutSpread } = massacreTargets(sweep.systems, sweep.centre, {
-          radiusLy: a.radius_ly,
+          // Past covered_ly - margin a source could have a pirate neighbour that was not fetched.
+          // A negative radius lists nothing, not even a target at distance 0.
+          radiusLy: sweep.partial ? Math.min(a.radius_ly, sweep.coveredLy - MASSACRE_MARGIN_LY) : a.radius_ly,
           maxStarLs: a.max_star_ls
         });
         notes.push(
@@ -46898,15 +47948,14 @@ function registerSystemTools(server, deps) {
           );
         }
         if (sweep.partial) {
-          notes.push(
-            "Spansh did not return every system in time: a source can look primary when a pirate faction near the edge was missed."
-          );
+          notes.push(partialNote(sweep.coveredLy));
         }
         return {
           near,
           searched: sweep.systems.length,
           left_out_spread: leftOutSpread,
           partial: sweep.partial,
+          ...sweep.partial ? { covered_ly: Math.floor(sweep.coveredLy * 10) / 10 } : {},
           travel: describeRules(rules).travel,
           targets: targets.slice(0, a.limit).map((t) => ({
             target_faction: t.faction,
@@ -46945,6 +47994,121 @@ function registerSystemTools(server, deps) {
       }
     )
   );
+  server.registerTool(
+    "ground_cz_targets",
+    {
+      annotations: {
+        title: "Find Ground Conflict Zones",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      description: "Find likely ground (on-foot) conflict zones near you: systems with a faction at War or Civil War, settlements owned by the warring factions, and a Frontline Solutions station close to those settlements (within max_gap_ls of distance from the arrival star, so on the same planet or its moons) that meets the minimum pad; left_out.pad_too_small counts systems where only smaller-pad stations are close. Data older than max_age_hours (default 6) is left out: wars often end at the daily tick. The best station is the quickest to dock at (a planetary landing counts against it), then the one with most warring settlements nearby. For the top detail_count results, body detail says whether the station is a planetary port on the settlements' planet (drop: same_body) or an orbital station next to that planet and its moons (drop: orbital). drop: gap_only means the station and settlements are at about the same distance from the arrival star, but the body data could not confirm the same planet or its moons: check each settlement's body. drop: null (with near_body and body_family null, and no body on settlements) means no body detail was fetched: the result is beyond detail_count, the time limit was reached, or the fetch failed. Zones are likely, not confirmed. near defaults to the journal location.",
+      inputSchema: {
+        near: external_exports.string().optional().describe("Exact reference system name"),
+        radius_ly: Radius,
+        max_age_hours: external_exports.number().min(1).max(168).default(6),
+        max_gap_ls: external_exports.number().min(0.1).max(20).default(1),
+        detail_count: external_exports.number().int().min(0).max(15).default(8),
+        limit: external_exports.number().int().min(1).max(100).default(20),
+        preferences: PrefsPatchSchema.optional(),
+        use_preferences: external_exports.boolean().default(true)
+      }
+    },
+    wrap(
+      async (a) => {
+        const notes = [];
+        const near = await resolveNear(a.near, notes);
+        const rules = await resolveSearchRules(deps, a.preferences, a.use_preferences);
+        const deadline = now() + TIME_LIMIT_MS2;
+        const found = await deps.spansh.frontlineWarSystems(near, a.radius_ly, { deadline });
+        const { targets, leftOut } = groundCzTargets(found.systems, found.centre, {
+          now: now(),
+          maxAgeHours: a.max_age_hours,
+          maxGapLs: a.max_gap_ls,
+          minPad: rules.pad.size,
+          dockSeconds: (arrivalLs, planetary) => legSeconds({ distanceLy: 0, arrivalLs, planetary, stationKnown: true }, rules.travel).seconds
+        });
+        const shown = targets.slice(0, a.limit);
+        const details = /* @__PURE__ */ new Map();
+        let timedOut = 0;
+        for (const t of shown.slice(0, a.detail_count)) {
+          if (now() >= deadline) {
+            timedOut++;
+            continue;
+          }
+          try {
+            const bodies = await deps.spansh.systemBodies(t.system.id64);
+            if (!bodies.length)
+              notes.push(`No body detail for ${t.system.name}: Spansh returned no bodies.`);
+            else details.set(t.system.id64, czDetail(t.best, bodies, a.max_gap_ls));
+          } catch (err) {
+            notes.push(
+              `No body detail for ${t.system.name}: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+        notes.push(
+          "These are likely ground conflict zones, not confirmed: Spansh does not see live conflict zone signals, and a war can end at the daily tick."
+        );
+        if (timedOut) {
+          notes.push(
+            `${timedOut} ${timedOut === 1 ? "result is" : "results are"} without body detail: the time limit was reached. Call again to fill them in.`
+          );
+        }
+        if (found.partial) {
+          notes.push("Spansh did not return every system in time; results may be missing.");
+        }
+        const minutes2 = (s) => Math.round(s / 6) / 10;
+        return {
+          near,
+          searched: found.systems.length,
+          left_out: leftOut,
+          partial: found.partial,
+          travel: describeRules(rules).travel,
+          targets: shown.map((t) => {
+            const d = details.get(t.system.id64) ?? null;
+            const l = leg(t.distanceLy, rules.travel);
+            return {
+              system: t.system.name,
+              distance_ly: Math.round(t.distanceLy * 100) / 100,
+              jumps: l.jumps,
+              travel_min: minutes2(l.seconds),
+              age_hours: Math.round(t.ageHours * 10) / 10,
+              updated_at: t.system.updated_at,
+              warring_factions: t.warring,
+              best_station: {
+                name: t.best.name,
+                type: t.best.type,
+                pad: t.best.pad,
+                arrival_ls: Math.round(t.best.arrival_ls * 100) / 100,
+                dock_min: minutes2(t.best.dock_s),
+                drop: d?.drop ?? null,
+                near_body: d?.near_body ?? null,
+                settlements: t.best.settlements.map((s) => ({
+                  name: s.name,
+                  owner: s.owner,
+                  gap_ls: Math.round(s.gap_ls * 1e3) / 1e3,
+                  ...d ? { body: d.settlementBodies[s.name] ?? null } : {}
+                }))
+              },
+              other_frontline_stations: t.others.map((s) => ({
+                name: s.name,
+                type: s.type,
+                pad: s.pad,
+                arrival_ls: Math.round(s.arrival_ls * 100) / 100,
+                settlements: s.settlements.length
+              })),
+              warring_settlements: t.warringSettlements,
+              body_family: d?.body_family ?? null
+            };
+          }),
+          notes
+        };
+      }
+    )
+  );
 }
 
 // src/tools/inara.ts
@@ -47017,8 +48181,8 @@ function registerEdsmTools(server, deps) {
 }
 
 // src/routes/pool.ts
-var lc = (s) => s.toLowerCase();
-var namesOf = (s) => [s.label, ...s.aliases];
+var lc2 = (s) => s.toLowerCase();
+var namesOf2 = (s) => [s.label, ...s.aliases];
 function joinPurposes(a, b) {
   const parts = [a, b].flatMap((p) => p ? p.split("; ") : []);
   return parts.length ? [...new Set(parts)].join("; ") : null;
@@ -47027,8 +48191,8 @@ function buildPool(a, catalog) {
   const used = /* @__PURE__ */ new Set();
   const unique = (label) => {
     let candidate = label;
-    for (let n = 2; used.has(lc(candidate)); n++) candidate = `${label}-${n}`;
-    used.add(lc(candidate));
+    for (let n = 2; used.has(lc2(candidate)); n++) candidate = `${label}-${n}`;
+    used.add(lc2(candidate));
     return candidate;
   };
   const resolveEngineer = (name) => {
@@ -47047,13 +48211,16 @@ function buildPool(a, catalog) {
       );
     }
     const station = input2.station ?? (input2.system ? void 0 : engineer2?.base);
-    const key = engineer2 ? `${lc(engineer2.system)}|${lc(engineer2.base)}` : `${lc(system)}|${lc(station ?? "")}`;
-    const name = input2.label ?? engineer2?.name ?? input2.station ?? system;
+    const key = engineer2 ? `${lc2(engineer2.system)}|${lc2(engineer2.base)}` : `${lc2(system)}|${lc2(station ?? "")}${!station && input2.body ? `|${lc2(input2.body)}` : ""}`;
+    const name = input2.label ?? engineer2?.name ?? input2.station ?? input2.body ?? system;
     const hit = byKey.get(key);
     if (hit) {
-      if (!namesOf(hit).some((n) => lc(n) === lc(name))) hit.aliases.push(unique(name));
+      if (!namesOf2(hit).some((n) => lc2(n) === lc2(name))) hit.aliases.push(unique(name));
       if (input2.after) hit.after = [.../* @__PURE__ */ new Set([...hit.after ?? [], ...input2.after])];
       hit.purpose = joinPurposes(hit.purpose, over.purpose ?? null);
+      hit.notes = joinPurposes(hit.notes, over.notes ?? null);
+      hit.body ??= input2.body ?? null;
+      if (over.planStop !== void 0) hit.planStops.push(over.planStop);
       hit.engineer ??= engineer2;
       if (engineer2 || (over.kind ?? input2.kind) === "engineer") hit.kind = "engineer";
       return hit;
@@ -47064,34 +48231,43 @@ function buildPool(a, catalog) {
       aliases: [],
       system,
       station: station ?? null,
+      body: input2.body ?? null,
       engineer: engineer2,
       kind: over.kind ?? input2.kind ?? (engineer2 ? "engineer" : "other"),
       purpose: over.purpose ?? null,
-      after: input2.after
+      notes: over.notes ?? null,
+      after: input2.after,
+      planStops: over.planStop === void 0 ? [] : [over.planStop]
     };
     byKey.set(key, stop);
     return stop;
   };
   const entries = a.stops ?? [];
   const candidates = [];
+  const finished = /* @__PURE__ */ new Map();
   if (a.plan) {
+    const planStops = a.plan.stops.filter((s) => s.status !== "done" && s.status !== "skipped");
+    for (const s of a.plan.stops) {
+      if (s.status !== "done" && s.status !== "skipped") continue;
+      for (const n of [s.label, s.station, s.body, s.system]) if (n) finished.set(lc2(n), n);
+    }
     const named = /* @__PURE__ */ new Set();
-    for (const s of a.plan.stops) if (s.kind === "engineer" && s.label) named.add(lc(s.label));
+    for (const s of planStops) if (s.kind === "engineer" && s.label) named.add(lc2(s.label));
     for (const e of entries) {
       if ("one_of" in e) continue;
-      if (e.engineer) named.add(lc(e.engineer));
-      if (e.kind === "engineer" && e.label) named.add(lc(e.label));
+      if (e.engineer) named.add(lc2(e.engineer));
+      if (e.kind === "engineer" && e.label) named.add(lc2(e.label));
     }
     const byEngineer = /* @__PURE__ */ new Map();
     for (const item of a.plan.items) {
       if (!item.engineer || item.status === "done" || item.status === "skipped") continue;
-      const entry2 = byEngineer.get(lc(item.engineer)) ?? {
+      const entry2 = byEngineer.get(lc2(item.engineer)) ?? {
         id: item.id,
         name: item.engineer,
         descriptions: []
       };
       entry2.descriptions.push(item.description);
-      byEngineer.set(lc(item.engineer), entry2);
+      byEngineer.set(lc2(item.engineer), entry2);
     }
     const baseFor = /* @__PURE__ */ new Map();
     if (catalog) {
@@ -47102,26 +48278,27 @@ function buildPool(a, catalog) {
         } catch {
           continue;
         }
-        const here = a.plan.stops.filter(
-          (s) => s.kind === "engineer" && !s.station && !baseFor.has(s) && lc(s.system ?? "") === lc(e.system)
+        const here = planStops.filter(
+          (s) => s.kind === "engineer" && !s.station && !baseFor.has(s) && lc2(s.system ?? "") === lc2(e.system)
         );
-        const mentions = (s) => lc(`${s.label ?? ""} ${s.purpose ?? ""}`).includes(lc(e.name));
+        const mentions = (s) => lc2(`${s.label ?? ""} ${s.purpose ?? ""}`).includes(lc2(e.name));
         const match = here.find(mentions) ?? (named.has(key) ? void 0 : here[0]);
         if (match) baseFor.set(match, { base: e.base, engineer: e.name });
       }
     }
-    for (const s of a.plan.stops) {
+    for (const s of planStops) {
       candidates.push({
         fixed: make(
           {
             label: s.label,
             system: s.system,
             station: s.station ?? baseFor.get(s)?.base,
+            body: s.body,
             engineer: baseFor.get(s)?.engineer,
             kind: s.kind,
             after: s.after
           },
-          { purpose: s.purpose }
+          { purpose: s.purpose, notes: s.notes, planStop: a.plan.stops.indexOf(s) }
         )
       });
     }
@@ -47153,26 +48330,30 @@ function buildPool(a, catalog) {
   const notes = [];
   const known = /* @__PURE__ */ new Map();
   for (const c of candidates) {
-    if ("group" in c) known.set(lc(c.group), c.group);
+    if ("group" in c) known.set(lc2(c.group), c.group);
     for (const s of "fixed" in c ? [c.fixed] : c.options) {
-      for (const n of namesOf(s)) known.set(lc(n), n);
+      for (const n of namesOf2(s)) known.set(lc2(n), n);
     }
   }
   for (const l of [...a.only ?? [], ...a.skip ?? []]) {
-    if (!known.has(lc(l))) {
+    if (!known.has(lc2(l)) && finished.has(lc2(l))) {
+      notes.push(`"${l}" is done or skipped in the plan, so the route leaves it out.`);
+      continue;
+    }
+    if (!known.has(lc2(l))) {
       throw new UserError(`Unknown stop label "${l}". Known: ${[...known.values()].join(", ")}`);
     }
   }
-  const only = a.only ? new Set(a.only.map(lc)) : null;
-  const skip = new Set((a.skip ?? []).map(lc));
+  const only = a.only ? new Set(a.only.map(lc2)) : null;
+  const skip = new Set((a.skip ?? []).map(lc2));
   const keep = (s, viaGroup) => {
-    const names = namesOf(s).map(lc);
+    const names = namesOf2(s).map(lc2);
     return (!only || viaGroup || names.some((n) => only.has(n))) && !names.some((n) => skip.has(n));
   };
   const kept = candidates.map((c) => {
     if ("fixed" in c) return keep(c.fixed, false) ? [c.fixed] : [];
-    if (skip.has(lc(c.group))) return [];
-    const viaGroup = !!only?.has(lc(c.group));
+    if (skip.has(lc2(c.group))) return [];
+    const viaGroup = !!only?.has(lc2(c.group));
     return [...new Set(c.options.filter((o) => keep(o, viaGroup)))];
   });
   const fixedStops = new Set(
@@ -47190,8 +48371,8 @@ function buildPool(a, catalog) {
     }
     const met = options.length > 1 ? options.find((o) => fixedStops.has(o)) : void 0;
     groupLabels.set(
-      lc(c.group),
-      (met ? [met] : options).map((o) => lc(o.label))
+      lc2(c.group),
+      (met ? [met] : options).map((o) => lc2(o.label))
     );
     if (options.length === 0) {
       notes.push(`Group "${c.group}" has no stops left after only/skip; dropped.`);
@@ -47208,17 +48389,17 @@ function buildPool(a, catalog) {
   });
   if (stops.length === 0 && groups.length === 0) throw new UserError("No stops to route.");
   const all = [.../* @__PURE__ */ new Set([...stops, ...groups.flatMap((g) => g.options)])];
-  const present = new Map(all.flatMap((s) => namesOf(s).map((n) => [lc(n), lc(s.label)])));
+  const present = new Map(all.flatMap((s) => namesOf2(s).map((n) => [lc2(n), lc2(s.label)])));
   const rulesApplied = [];
   const after = /* @__PURE__ */ new Map();
   const planFallback = !!a.plan && a.planRules;
   const fallbackTargets = all.filter((s) => s.kind === "shop" || s.kind === "trader");
   let fallbackUsed = false;
   for (const s of all) {
-    const key = lc(s.label);
+    const key = lc2(s.label);
     if (s.after === void 0) {
       if (!planFallback || s.kind !== "engineer") continue;
-      const targets = fallbackTargets.filter((t) => t !== s).map((t) => lc(t.label));
+      const targets = fallbackTargets.filter((t) => t !== s).map((t) => lc2(t.label));
       if (targets.length === 0) continue;
       after.set(key, targets);
       fallbackUsed = true;
@@ -47227,8 +48408,8 @@ function buildPool(a, catalog) {
     const resolved = [];
     const named = [];
     for (const l of s.after) {
-      const main2 = present.get(lc(l));
-      const expanded = groupLabels.get(lc(l)) ?? (main2 ? [main2] : []);
+      const main2 = present.get(lc2(l));
+      const expanded = groupLabels.get(lc2(l)) ?? (main2 ? [main2] : []);
       const targets = expanded.filter((t) => t !== key);
       if (targets.length === 0) {
         notes.push(`Rule "${s.label} after ${l}" ignored: ${l} is not in this route.`);
@@ -47301,16 +48482,17 @@ function solveRoute(input2) {
 
 // src/tools/routes.ts
 var min2 = (s) => Math.round(s / 6) / 10;
-var lc2 = (s) => s.toLowerCase();
+var lc3 = (s) => s.toLowerCase();
 var LONG_LEG_LY = 200;
 var PLOT_ROUNDS = 2;
 var PLOT_DIFF = 0.2;
 var PLOT_PENDING_NOTE = "Spansh is still plotting; call again to finish.";
 var PLOT_BUDGET_MS = 4e4;
 var StopInputSchema = external_exports.object({
-  label: external_exports.string().min(1).optional().describe("Name for rules and output; default the engineer, station or system"),
+  label: external_exports.string().min(1).optional().describe("Name for rules and output; default the engineer, station, body or system"),
   system: external_exports.string().optional(),
   station: external_exports.string().optional(),
+  body: external_exports.string().min(1).optional().describe("Planet or moon, for a stop with no station"),
   engineer: external_exports.string().optional().describe("Places the stop from the engineer catalog"),
   kind: StopKind.optional(),
   after: external_exports.array(external_exports.string()).optional().describe("Labels of stops that must come before this one")
@@ -47334,7 +48516,7 @@ function registerRouteTools(server, deps) {
         idempotentHint: true,
         openWorldHint: true
       },
-      description: "Order the stops for a build: shops, material traders and engineers, from a plan (plan_id) or a list (stops). Uses Spansh coordinates and the travel-time model. For each engineer stop, set `after` to the shops and traders that supply what that engineer needs (the module to buy, the materials to trade). Give `after: []` to an engineer who needs nothing from the other stops, so they can come first. Without your rules, a plan puts every engineer after every shop and trader. Use `one_of` for alternatives, for example two engineers who both do the work; the tool tries every combination (at most 16) and keeps the fastest. `only` and `skip` choose stops from the plan, so one plan can serve several trips. One place (the same engineer, or the same system and station) can be an option in several groups; it is visited once, and each stop's `meets` lists the groups it covers. Leg times are estimates from straight-line jumps; pass plot: true to plot the chosen route with Spansh.",
+      description: "Order the stops of a plan (plan_id) or a list (stops): shops, material traders and engineers for a build, or the systems, bodies and stations of a route. Plan stops marked done or skipped are left out. Uses Spansh coordinates and the travel-time model. For each engineer stop, set `after` to the shops and traders that supply what that engineer needs (the module to buy, the materials to trade). Give `after: []` to an engineer who needs nothing from the other stops, so they can come first. Without your rules, a plan puts every engineer after every shop and trader. Use `one_of` for alternatives, for example two engineers who both do the work; the tool tries every combination (at most 16) and keeps the fastest. `only` and `skip` choose stops from the plan, so one plan can serve several trips. One place (the same engineer, or the same system and station) can be an option in several groups; it is visited once, and each stop's `meets` lists the groups it covers. Leg times are estimates from straight-line jumps; pass plot: true to plot the chosen route with Spansh.",
       inputSchema: {
         plan_id: external_exports.string().optional(),
         stops: external_exports.array(StopEntrySchema).optional(),
@@ -47369,9 +48551,9 @@ function registerRouteTools(server, deps) {
         countCombinations(pool.groups.map((g) => g.options.length));
         const all = [.../* @__PURE__ */ new Set([...pool.stops, ...pool.groups.flatMap((g) => g.options)])];
         const names = (s) => [s.label, ...s.aliases];
-        const labelIndex = new Map(all.map((s, i) => [lc2(s.label), i]));
+        const labelIndex = new Map(all.map((s, i) => [lc3(s.label), i]));
         const graph = all.map(
-          (s) => (pool.after.get(lc2(s.label)) ?? []).flatMap((l) => labelIndex.get(l) ?? [])
+          (s) => (pool.after.get(lc3(s.label)) ?? []).flatMap((l) => labelIndex.get(l) ?? [])
         );
         const cycle = findCycle(graph);
         if (cycle) {
@@ -47409,7 +48591,7 @@ function registerRouteTools(server, deps) {
           const seen = nodeOfStop.get(s);
           if (seen !== void 0) return seen;
           const p = await placeStop(s);
-          const key2 = p.station ? `${lc2(p.system)}|${lc2(p.station)}` : null;
+          const key2 = p.station ? `${lc3(p.system)}|${lc3(p.station)}` : null;
           const hit = merge2 && key2 ? byStation.get(key2) : void 0;
           let idx;
           if (hit !== void 0) {
@@ -47418,6 +48600,9 @@ function registerRouteTools(server, deps) {
             node2.engineer ??= s.engineer?.name ?? null;
             if (s.kind === "engineer" || s.engineer) node2.kind = "engineer";
             node2.purpose = joinPurposes(node2.purpose, s.purpose);
+            node2.notes = joinPurposes(node2.notes, s.notes);
+            node2.body ??= s.body;
+            node2.planStops.push(...s.planStops);
             idx = hit;
           } else {
             nodes.push({
@@ -47425,12 +48610,15 @@ function registerRouteTools(server, deps) {
               place: p,
               engineer: s.engineer?.name ?? null,
               kind: s.kind,
-              purpose: s.purpose
+              purpose: s.purpose,
+              body: s.body,
+              notes: s.notes,
+              planStops: [...s.planStops]
             });
             idx = nodes.length - 1;
             if (merge2 && key2) byStation.set(key2, idx);
           }
-          nodeOf.set(lc2(s.label), idx);
+          nodeOf.set(lc3(s.label), idx);
           nodeOfStop.set(s, idx);
           return idx;
         };
@@ -47493,7 +48681,7 @@ function registerRouteTools(server, deps) {
           ...returnPlace ? [returnPlace] : []
         ];
         const leg = (from, to) => legBetween(places[from], places[to], travel);
-        const sameSystem = (f, t) => lc2(places[f].system) === lc2(places[t].system);
+        const sameSystem = (f, t) => lc3(places[f].system) === lc3(places[t].system);
         const plottedJumps = /* @__PURE__ */ new Map();
         const unfinished = /* @__PURE__ */ new Set();
         const failed = /* @__PURE__ */ new Map();
@@ -47587,6 +48775,8 @@ function registerRouteTools(server, deps) {
             engineer: node2?.engineer ?? null,
             kind: node2 ? node2.kind : "other",
             purpose: node2 ? node2.purpose : null,
+            ...node2?.body ? { body: node2.body } : {},
+            ...node2?.notes ? { notes: node2.notes } : {},
             meets: allChosen.filter((c) => c.option === t).map((c) => c.group),
             jumps: plottedJumps.get(key(f, t)) ?? l.jumps,
             leg_min: min2(seconds),
@@ -47622,18 +48812,26 @@ function registerRouteTools(server, deps) {
         let saved = false;
         if (a.save_to_plan && a.plan_id) {
           try {
-            await deps.plans.setRoute(a.plan_id, {
-              computed_at: new Date(now()).toISOString(),
-              from: startPlace.system,
-              stops: [
-                ...solved.order.map(optionLabel),
-                ...returnPlace ? [
-                  `return to ${returnPlace.system}${returnPlace.station ? ` \u2014 ${returnPlace.station}` : ""}`
-                ] : []
-              ],
-              total_min: total,
-              plotted: a.plot && allPlotted
-            });
+            await deps.plans.setRoute(
+              a.plan_id,
+              {
+                computed_at: new Date(now()).toISOString(),
+                from: startPlace.system,
+                stops: [
+                  ...solved.order.map(optionLabel),
+                  ...returnPlace ? [
+                    `return to ${returnPlace.system}${returnPlace.station ? ` \u2014 ${returnPlace.station}` : ""}`
+                  ] : []
+                ],
+                total_min: total,
+                plotted: a.plot && allPlotted,
+                stop_indexes: [
+                  ...solved.order.map((i) => [...new Set(nodes[i].planStops)]),
+                  ...returnPlace ? [[]] : []
+                ]
+              },
+              { stops: plan?.stops }
+            );
             saved = true;
           } catch (err) {
             notes.add(`The route was not saved to plan "${a.plan_id}": ${reason(err)}`);
@@ -47663,7 +48861,7 @@ function registerRouteTools(server, deps) {
 
 // src/tools/plans.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir6, readFile as readFile7, rename as rename5, stat as stat7, unlink as unlink2, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir7, readFile as readFile7, rename as rename5, stat as stat7, unlink as unlink3, writeFile as writeFile5 } from "fs/promises";
 import path13 from "path";
 var MAX_ECHOED_PLAN = 100 * 1024;
 function registerPlanTools(server, deps) {
@@ -47703,7 +48901,7 @@ ${tail}`);
         idempotentHint: true,
         openWorldHint: false
       },
-      description: "List saved build plans with item counts and progress."
+      description: "List saved plans with item counts, progress and next_stop (the first stop still to do). A plan is a ship build or a route, or both."
     },
     wrapWarn(async () => plans.list(), warnings)
   );
@@ -47717,10 +48915,13 @@ ${tail}`);
         idempotentHint: true,
         openWorldHint: false
       },
-      description: "Get a saved plan by id.",
+      description: "Get a saved plan (a build or a route) by id. next_stop is the first stop still to do, in the saved route's order when there is one, else in the order of stops.",
       inputSchema: { id: external_exports.string() }
     },
-    wrapWarn(async ({ id }) => plans.get(id), warnings)
+    wrapWarn(async ({ id }) => {
+      const plan = await plans.get(id);
+      return { ...plan, next_stop: nextStop(plan) };
+    }, warnings)
   );
   server.registerTool(
     "plan_upsert",
@@ -47732,7 +48933,7 @@ ${tail}`);
         idempotentHint: true,
         openWorldHint: false
       },
-      description: "Create or replace a build plan. Items are things to buy, engineer, unlock, gather or trade, plus refits (moving modules between slots, storing modules, or a fitting decision); stops are the places to visit (optionally with label, kind and after rules); route is the saved visiting order. Replacing keeps created_at.",
+      description: "Create or replace a plan. A plan is a ship build, a route, or both: for example system X, planet Y for bios, then planet Z, then station A to hand in. Items are things to buy, engineer, unlock, gather or trade, plus refits (moving modules between slots, storing modules, or a fitting decision). Stops are the places to visit, each with a system and optionally a station or body (planet or moon), a label, a kind, a status (todo, done, skipped), notes and after rules. Without a saved route, the order of stops is the visiting order; route is the order route_stops saved. Replacing keeps created_at.",
       inputSchema: { plan: PlanInputSchema }
     },
     wrapWarn(
@@ -47781,6 +48982,54 @@ ${tail}`);
       warnings
     )
   );
+  server.registerTool(
+    "plan_update_stop",
+    {
+      annotations: {
+        title: "Update Plan Stop",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      description: "Set the status (todo, done, skipped) and/or notes of one stop in a plan. Name the stop by label (its label, else its station, body or system) or by index in the plan's stops, from 0; give exactly one. Mark a stop done when the player has finished there; returns the plan with the new next_stop.",
+      inputSchema: {
+        plan_id: external_exports.string(),
+        label: external_exports.string().min(1).optional(),
+        index: external_exports.number().int().min(0).optional(),
+        status: StopStatus.optional(),
+        notes: external_exports.string().optional()
+      }
+    },
+    wrapWarn(
+      async (a) => {
+        if (a.label === void 0 === (a.index === void 0)) {
+          throw new UserError("Give exactly one of label or index to name the stop");
+        }
+        if (a.status === void 0 && a.notes === void 0) {
+          throw new UserError("Give status or notes to update");
+        }
+        const which = a.label !== void 0 ? `"${a.label}"` : String(a.index);
+        try {
+          const plan = await plans.updateStop(
+            a.plan_id,
+            { label: a.label, index: a.index },
+            { status: a.status, notes: a.notes }
+          );
+          return { ...plan, next_stop: nextStop(plan) };
+        } catch (err) {
+          const changes = [
+            ...a.status !== void 0 ? [`status: ${a.status}`] : [],
+            ...a.notes !== void 0 ? ["notes changed"] : []
+          ].join(", ");
+          throw new UserError(
+            `Stop ${which} in plan "${a.plan_id}" was not updated (${changes}). ${reason(err)}`
+          );
+        }
+      },
+      warnings
+    )
+  );
   server.registerTool(
     "plan_delete",
     {
@@ -47831,13 +49080,13 @@ ${tail}`);
           if (!a.overwrite && await exists(target)) {
             throw new UserError(`${target} exists; pass overwrite: true to replace it`);
           }
-          await mkdir6(path13.dirname(target), { recursive: true });
+          await mkdir7(path13.dirname(target), { recursive: true });
           const tmp = `${target}.${process.pid}.${randomUUID2()}.tmp`;
           try {
             await writeFile5(tmp, text);
             await rename5(tmp, target);
           } catch (err) {
-            await unlink2(tmp).catch(() => void 0);
+            await unlink3(tmp).catch(() => void 0);
             throw err;
           }
         });
@@ -47945,35 +49194,35 @@ var TOP = 5;
 var NO_CATALOG = 'Module names need the game data catalog. Call any catalog tool (for example catalog_module) or cache_refresh with source "catalog".';
 var cap = (s) => s[0].toUpperCase() + s.slice(1);
 var titleCase = (symbol2) => symbol2.split("_").filter(Boolean).map(cap).join(" ");
-var str4 = (v) => typeof v === "string" ? v : void 0;
-var num5 = (v) => typeof v === "number" ? v : 0;
+var str5 = (v) => typeof v === "string" ? v : void 0;
+var num6 = (v) => typeof v === "number" ? v : 0;
 var list = (v) => Array.isArray(v) ? v : [];
-var same3 = (a, b) => a.toLowerCase() === b.toLowerCase();
+var same5 = (a, b) => a.toLowerCase() === b.toLowerCase();
 var byText = (a, b) => a.localeCompare(b);
 function vsMean(price, mean) {
   return mean > 0 ? Math.round((price - mean) / mean * 100) : null;
 }
 function marketRows(file2, commodity) {
   const rows = list(file2.data.Items).map((i) => ({
-    name: str4(i.Name_Localised) ?? str4(i.Name) ?? "?",
-    category: str4(i.Category_Localised) ?? str4(i.Category) ?? "",
+    name: str5(i.Name_Localised) ?? str5(i.Name) ?? "?",
+    category: str5(i.Category_Localised) ?? str5(i.Category) ?? "",
     i
   })).filter((r) => !commodity || r.name.toLowerCase().includes(commodity.toLowerCase())).sort((a, b) => byText(a.category, b.category) || byText(a.name, b.name));
-  const sells = rows.filter((r) => num5(r.i.Stock) > 0 && num5(r.i.BuyPrice) > 0).map((r) => ({
+  const sells = rows.filter((r) => num6(r.i.Stock) > 0 && num6(r.i.BuyPrice) > 0).map((r) => ({
     name: r.name,
     category: r.category,
-    buy_price: num5(r.i.BuyPrice),
-    stock: num5(r.i.Stock),
-    mean_price: num5(r.i.MeanPrice),
-    vs_mean_pct: vsMean(num5(r.i.BuyPrice), num5(r.i.MeanPrice))
+    buy_price: num6(r.i.BuyPrice),
+    stock: num6(r.i.Stock),
+    mean_price: num6(r.i.MeanPrice),
+    vs_mean_pct: vsMean(num6(r.i.BuyPrice), num6(r.i.MeanPrice))
   }));
   const buys = rows.filter((r) => marketDemand(r.i) > 0).map((r) => ({
     name: r.name,
     category: r.category,
-    sell_price: num5(r.i.SellPrice),
+    sell_price: num6(r.i.SellPrice),
     demand: marketDemand(r.i),
-    mean_price: num5(r.i.MeanPrice),
-    vs_mean_pct: vsMean(num5(r.i.SellPrice), num5(r.i.MeanPrice))
+    mean_price: num6(r.i.MeanPrice),
+    vs_mean_pct: vsMean(num6(r.i.SellPrice), num6(r.i.MeanPrice))
   }));
   return { sells, buys };
 }
@@ -47985,7 +49234,7 @@ async function modules(file2, catalog, notes) {
   const cat = await catalog?.peek().catch(() => null);
   if (!cat) notes.push(NO_CATALOG);
   return list(file2.data.Items).flatMap((i) => {
-    const symbol2 = str4(i.Name);
+    const symbol2 = str5(i.Name);
     if (!symbol2) return [];
     const found = cat?.moduleBySymbol(symbol2);
     return [
@@ -47995,7 +49244,7 @@ async function modules(file2, catalog, notes) {
         class: found?.class ?? null,
         rating: found?.rating ?? null,
         group: found?.group ?? null,
-        price: num5(i.BuyPrice)
+        price: num6(i.BuyPrice)
       }
     ];
   });
@@ -48024,8 +49273,8 @@ function groupModules(mods) {
 }
 function ships(file2) {
   return list(file2.data.PriceList).map((s) => ({
-    name: str4(s.ShipType_Localised) ?? titleCase(str4(s.ShipType) ?? "?"),
-    price: num5(s.ShipPrice)
+    name: str5(s.ShipType_Localised) ?? titleCase(str5(s.ShipType) ?? "?"),
+    price: num6(s.ShipPrice)
   })).sort((a, b) => a.price - b.price);
 }
 function registerStationTools(server, deps) {
@@ -48069,7 +49318,7 @@ function registerStationTools(server, deps) {
             notes.push(`No ${kind2} data. Open the ${kind2} screen at a station first.`);
             continue;
           }
-          if (docked && !same3(file2.station, docked)) {
+          if (docked && !same5(file2.station, docked)) {
             notes.push(
               `${label} last opened at ${file2.station} (${file2.system}), not the station where you are docked.`
             );
@@ -48717,6 +49966,7 @@ function registerSettingsTools(server, deps) {
         const files = (await existing(localDir, [
           "plans.json",
           "preferences.json",
+          "activity.json",
           "secrets.json",
           "secrets.enc"
         ])).filter((n) => path14.resolve(localDir, n) !== own2);
@@ -48765,6 +50015,13 @@ function createServer3(deps) {
       warnings: deps.planWarnings ?? deps.syncWarnings
     });
   if (deps.prefs) registerPrefsTools(server, { prefs: deps.prefs, warnings: deps.syncWarnings });
+  if (deps.activity) {
+    registerActivityTools(server, {
+      activity: deps.activity,
+      journal: deps.journal,
+      warnings: deps.syncWarnings
+    });
+  }
   if (deps.settingsPage && deps.settings && deps.secrets) {
     registerSettingsTools(server, {
       page: deps.settingsPage,