thursday-agent 0.18.0 → 0.19.0

package/bin/lock.mjs

@@ -6,7 +6,7 @@
 import { spawnSync } from "node:child_process";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { startsWithMac } from "./autostart.mjs";
+import { backgroundJob } from "./background.mjs";
 import { thursdayCommand } from "./tools.mjs";
 
 /** Beside the database, and named so a checkout never commits it (`*.local.*`). */
@@ -21,37 +21,70 @@ export function runningOn(home) {
     return null;
   }
   if (!Number.isInteger(held?.pid) || held.pid === process.pid) return null;
-  try {
-    // Signal 0 asks whether the process exists and sends nothing
-    process.kill(held.pid, 0);
-  } catch (error) {
-    // Someone else's process by that id is still a live one
-    if (error?.code !== "EPERM") return null;
-  }
-  // A lock left by a server that died without its exit (a kill -9, a power cut) names a pid
-  // another process may hold after a restart, which would refuse every start until the file
-  // was deleted by hand: the pid is this server only if it started when the lock says. Where
-  // `ps` cannot say (Windows), or the lock predates `started`, the live pid is all there is.
-  const started = startedAt(held.pid);
-  if (typeof held.started === "string" && started && started !== held.started)
-    return null;
+  if (!stillRuns(held)) return null;
   return {
     pid: held.pid,
     url: String(held.url ?? ""),
     // Null from `pnpm dev`, and from a server started before the lock said
     version: typeof held.version === "string" ? held.version : null,
+    background: held.background === true,
   };
 }
 
+/**
+ * Whether the process a lock names is still the one that wrote it. A lock left by a process
+ * that died without its exit (a kill -9, a power cut) names a pid another process may hold
+ * after a restart, which would refuse every start until the file was deleted by hand: the pid
+ * is the writer only if it started when the lock says. Where `ps` cannot say (Windows), or the
+ * lock predates its start time, the live pid is all there is.
+ */
+export function stillRuns(held) {
+  try {
+    // Signal 0 asks whether the process exists and sends nothing
+    process.kill(held.pid, 0);
+  } catch (error) {
+    // Someone else's process by that id is still a live one
+    if (error?.code !== "EPERM") return false;
+  }
+  // Compared in UTC: `ps` writes the reader's zone, and a server under launchd (no TZ), a
+  // terminal that exports one, or a Mac that moved zones since it started spelled one start
+  // two ways — the server read as gone, and a second one opened the same database. A lock
+  // written before `startedUtc` has `started` alone, in its writer's zone.
+  const [said, zone] =
+    typeof held.startedUtc === "string"
+      ? [held.startedUtc, "UTC"]
+      : [held.started, undefined];
+  if (typeof said !== "string") return true;
+  const started = startedAt(held.pid, zone);
+  return !started || started === said;
+}
+
+/**
+ * Whether the server holding this folder is `pid`, or runs under it: launchd knows a job by the
+ * process it started, and a version manager's shim (Volta's) starts node as its child rather
+ * than becoming it.
+ */
+export function heldBy(running, pid) {
+  if (!running || !pid) return false;
+  return (
+    running.pid === pid ||
+    Number(ps(["-o", "ppid=", "-p", String(running.pid)])) === pid
+  );
+}
+
 // LC_ALL=C: a start time is compared as `ps` wrote it, so both reads spell it alike
-const ps = (...args) =>
+const ps = (args, zone) =>
   spawnSync("ps", args, {
     encoding: "utf8",
-    env: { ...process.env, LC_ALL: "C" },
+    env: { ...process.env, LC_ALL: "C", ...(zone ? { TZ: zone } : {}) },
   }).stdout?.trim() ?? "";
 
-/** When a process started, to the second, as `ps` has it. Empty where it cannot say. */
-const startedAt = (pid) => ps("-o", "lstart=", "-p", String(pid));
+/**
+ * When a process started, to the second, as `ps` has it in `zone` (the reader's own when none).
+ * Empty where it cannot say.
+ */
+export const startedAt = (pid, zone) =>
+  ps(["-o", "lstart=", "-p", String(pid)], zone);
 
 /**
  * Where a process runs, as `ps` has it: the terminal it is attached to (null when none), when
@@ -59,27 +92,27 @@ const startedAt = (pid) => ps("-o", "lstart=", "-p", String(pid));
  * `npx thursday-agent`, not the Node process under it. Null where `ps` cannot say (Windows).
  */
 function whereRuns(pid) {
-  const [tty, group, ...started] = ps(
+  const [tty, group, ...started] = ps([
     "-o",
     "tty=,pgid=,lstart=",
     "-p",
     String(pid),
-  ).split(/\s+/);
+  ]).split(/\s+/);
   if (!tty || !group) return null;
   return {
     terminal: tty === "??" || tty === "?" ? null : tty,
     group,
-    // "Fri Sep 25 20:55:51 2026" to the minute
+    // "Fri Sep 25 20:55:51 2026" to the minute, in the reader's zone: it is read, not compared
     since: started.join(" ").replace(/:\d\d \d{4}$/, ""),
-    typed: ps("-o", "command=", "-p", group),
+    typed: ps(["-o", "command=", "-p", group]),
   };
 }
 
 /**
  * How to stop the server with this pid, said where it can be done. A person told only "stop
  * it" looked for a terminal they could not find: the one it runs in is named, with a command
- * that does the same from any terminal. One that starts with the Mac is started again by
- * launchd, so it is stopped by turning that off. Lines to print, without indent.
+ * that does the same from any terminal. One that runs in the background is started again by
+ * launchd, so it is stopped by stopping that. Lines to print, without indent.
  */
 export function stopLines(pid, home) {
   const where = whereRuns(pid);
@@ -88,10 +121,8 @@ export function stopLines(pid, home) {
       `It runs in a terminal (${where.terminal}${where.typed ? `, ${where.typed}` : ""}, since ${where.since}).`,
       `Ctrl+C there, or from any terminal: kill -INT -${where.group}`,
     ];
-  if (startsWithMac(home))
-    return [
-      `It starts with your Mac. To stop it: ${thursdayCommand()} autostart --off`,
-    ];
+  if (backgroundJob()?.home === home)
+    return [`It runs in the background. To stop it: ${thursdayCommand()} stop`];
   if (where) return [`It runs in the background. To stop it: kill ${pid}`];
   return ["Ctrl+C where it runs."];
 }
@@ -120,9 +151,13 @@ export function holdFolder(home, url, version) {
       file,
       `${JSON.stringify({
         pid: process.pid,
+        startedUtc: startedAt(process.pid, "UTC") || undefined,
+        // What a starter from before `startedUtc` reads, in this process's zone
         started: startedAt(process.pid) || undefined,
         url,
         version,
+        // Which one launchd started, so a stop can end it when launchd did not (background.mjs)
+        background: process.env.THURSDAY_BACKGROUND ? true : undefined,
       })}\n`,
     );
   } catch {

package/bin/thursday.mjs

@@ -14,12 +14,19 @@ import {
   symlinkSync,
 } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+import { backgroundJob, keepLogShort, offerBackground } from "./background.mjs";
 import { askToSetDatabaseAside, MIGRATION_FAILED_EXIT } from "./database.mjs";
 import { holdFolder, runningOn, stopLines } from "./lock.mjs";
 import { freePort } from "./port.mjs";
-import { ROOT, thursdayCommand, toolPath } from "./tools.mjs";
+import {
+  commandFor,
+  DEFAULT_HOME,
+  openBrowser,
+  ROOT,
+  thursdayCommand,
+  toolPath,
+} from "./tools.mjs";
 
 const { version, name } = JSON.parse(
   await readFile(join(ROOT, "package.json"), "utf8"),
@@ -39,8 +46,11 @@ if (has("-h", "--help")) {
   ${name} ${version}
 
   Usage
-    $ ${command} [options]
-    $ ${command} autostart [--off]   Start with the computer, macOS only
+    $ ${command} [options]          Start it here, in this terminal
+    $ ${command} start [options]    Keep it running in the background, and start it
+                                    when you log in (macOS)
+    $ ${command} stop               Stop it in the background
+    $ ${command} status             Whether it runs, where, and how to reach it
 
   Options
     --port <n>     Port to serve on (default 4747, or the next free one)
@@ -72,62 +82,112 @@ if (!APP) {
   process.exit(1);
 }
 
-/**
- * The user's files: database, workspace, installed skills. An installed package
- * keeps them in the home folder, never inside the package — an upgrade replaces
- * that. A checkout keeps them in the checkout, which is where `pnpm dev` already
- * writes them (config.ts DATA_DIR): a build started here opens the data it was
- * developed against, not a second, empty one beside it.
- */
-const DEFAULT_HOME = APP === ROOT ? join(homedir(), ".thursday") : ROOT;
-
-const asked = flag("port") ?? process.env.PORT;
+// An exported `PORT=` with nothing in it asks for no port
+const asked = flag("port") ?? (process.env.PORT?.trim() || undefined);
 const home = resolve(flag("home") || process.env.THURSDAY_HOME || DEFAULT_HOME);
 
-// Turning it on or off is the whole command; it never goes on to serve.
-if (argv[0] === "autostart") {
-  const { autostart } = await import("./autostart.mjs");
-  await autostart({ root: ROOT, home, off: has("--off") });
-  process.exit(0);
-}
-
-/** A browser that will not open is not a failure. */
-function openBrowser(url) {
-  const [command, args] =
-    process.platform === "darwin"
-      ? ["open", [url]]
-      : process.platform === "win32"
-        ? ["cmd", ["/c", "start", "", url]]
-        : ["xdg-open", [url]];
-  spawn(command, args, { stdio: "ignore" }).on("error", () => {});
+// The background (background.mjs): each is the whole command, and never goes on to serve.
+// `autostart` and `autostart --off` are what earlier versions called start and stop.
+const said =
+  argv[0] === "autostart" ? (has("--off") ? "stop" : "start") : argv[0];
+const background = ["start", "stop", "status"].includes(said) ? said : null;
+/** A start that could not run it in the background, and serves in this terminal instead. */
+let fellBack = false;
+if (background) {
+  const { printStatus, startInBackground, stopBackground } = await import(
+    "./background.mjs"
+  );
+  if (background === "status") {
+    printStatus({ home });
+    process.exit(0);
+  }
+  if (background === "stop")
+    process.exit((await stopBackground({ home })) ? 0 : 1);
+  const started = await startInBackground({
+    root: ROOT,
+    home,
+    port: asked,
+    open: !has("--no-open"),
+    version,
+  });
+  if (started === true) process.exit(0);
+  // A person at a terminal still gets it running, there, for as long as it stays open, as the
+  // first run's question does. "held" is a folder something else serves already; a script
+  // gets the failure
+  if (started === "held" || !process.stdin.isTTY || !process.stdout.isTTY)
+    process.exit(1);
+  fellBack = true;
 }
 
-// Before a port is picked: a second server on this folder would take the next one, and
-// serve the same calls, jobs and phone twice (lock.mjs). Run again, it is usually the app
-// they came for — a second `npx` once its tab is closed — so that one opens instead. One of
-// another version does not: they ran this one to have this one.
-const running = runningOn(home);
-if (running) {
+/**
+ * Leaves when this folder already has a server: a second one would take the next port, and
+ * serve the same calls, jobs and phone twice (lock.mjs). Run again, it is usually the app they
+ * came for — a second `npx` once its tab is closed — so that one opens instead. One of another
+ * version does not: they ran this one to have this one.
+ */
+function leaveToRunning() {
+  const running = runningOn(home);
+  if (!running) return;
   const other =
     running.version && running.version !== version ? running.version : null;
   const opens = Boolean(running.url) && !other && !has("--no-open");
+  // The copy in the background moves to this version by starting it from this one: through
+  // npx pinned, since a bare `npx thursday-agent` is whichever version npm resolves that day
+  const command = thursdayCommand();
+  const moves =
+    other && backgroundJob()?.home === home
+      ? `  To move it to ${version}: ${commandFor(
+          "start",
+          home,
+          command === "npx thursday-agent"
+            ? `npx thursday-agent@${version}`
+            : command,
+        )}\n`
+      : null;
   console.log(
     `\n  Thursday${other ? ` ${other}` : ""} is already running on this data folder${running.url ? `: ${running.url}` : ""}\n${
       opens
         ? "  Opened it in your browser.\n"
-        : other
-          ? `  To run ${version} instead, stop that one and run this again.\n`
-          : ""
-    }${stopLines(running.pid, home)
-      .map((line) => `  ${line}\n`)
-      .join("")}`,
+        : (moves ??
+          (other
+            ? `  To run ${version} instead, stop that one and run this again.\n`
+            : ""))
+    }${
+      moves
+        ? ""
+        : stopLines(running.pid, home)
+            .map((line) => `  ${line}\n`)
+            .join("")
+    }`,
   );
   if (opens) openBrowser(running.url);
   process.exit(other ? 1 : 0);
 }
+
+// Before a port is picked
+leaveToRunning();
+
+if (fellBack) console.log("  Running it in this terminal instead.");
+else {
+  // A first run in a terminal asks once whether to keep it running in the background; said
+  // yes, the background serves and this run is done
+  const chose = await offerBackground({
+    root: ROOT,
+    home,
+    port: asked,
+    open: !has("--no-open"),
+    version,
+  });
+  if (chose !== "terminal") process.exit(chose === "background" ? 0 : 1);
+}
+// The question waits as long as the person does, and a start takes a minute: a server another
+// terminal started on this folder meanwhile is the one to use, not a second beside it
+leaveToRunning();
 const port = String(await freePort(asked, home));
 const url = `http://localhost:${port}`;
 holdFolder(home, url, version);
+// launchd writes the background's output to a log that nothing else trims
+if (process.env.THURSDAY_BACKGROUND) keepLogShort(home);
 /** Where config.ts DB_PATH puts the database under the home. */
 const database = join(home, "local.db");
 
@@ -173,6 +233,15 @@ function start() {
       THURSDAY_URL: url,
       // Where a bot's shell finds playwright-cli (workspace.ts TOOL_PATH)
       THURSDAY_TOOL_PATH: toolPath().join(":"),
+      // How it was started and what the person types to run it, for Settings to say where it
+      // runs and how to stop or keep it (features/settings/running.ts)
+      THURSDAY_RUNS: process.env.THURSDAY_BACKGROUND
+        ? "background"
+        : process.stdin.isTTY
+          ? "terminal"
+          : "elsewhere",
+      THURSDAY_COMMAND: thursdayCommand(),
+      THURSDAY_START: commandFor("start", home),
       PORT: port,
       // This machine only. A voice agent with a shell is not a thing to expose.
       // Never inherited: Docker exports HOSTNAME as the container and some

package/bin/tools.mjs

@@ -2,8 +2,10 @@
 // imports: this runs from the published `bin`, on a machine that has neither a
 // build nor a TypeScript loader.
 
+import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
+import { homedir } from "node:os";
 import { dirname, join, resolve, sep } from "node:path";
 
 const require = createRequire(import.meta.url);
@@ -11,22 +13,74 @@ const require = createRequire(import.meta.url);
 /** The checkout, or the installed package. */
 export const ROOT = resolve(import.meta.dirname, "..");
 
+/**
+ * Where the copy that runs in the background is installed (background.mjs). Beside the
+ * default data folder, so everything the app keeps on the computer is under one folder.
+ */
+export const PROGRAM = join(homedir(), ".thursday", "app");
+
+/** The one copy with the dev script beside it; the package ships no `scripts`. */
+export const isCheckout = (root) =>
+  existsSync(join(root, "scripts", "dev.mts"));
+
+/**
+ * The user's files when no `--home` is given: database, workspace, installed skills. An
+ * installed package keeps them in the home folder, never inside the package — an upgrade
+ * replaces that. A checkout keeps them in the checkout, which is where `pnpm dev` already
+ * writes them (config.ts DATA_DIR): a build started here opens the data it was developed
+ * against, not a second, empty one beside it.
+ */
+export const DEFAULT_HOME = isCheckout(ROOT)
+  ? ROOT
+  : join(homedir(), ".thursday");
+
 /**
  * What this person types to run the app, for a line that tells them to run it again. Only a
  * global install puts `thursday` on the PATH: said to someone who ran `npx`, it is a command
- * they do not have. npx names itself in npm_lifecycle_event and unpacks into its `_npx` cache;
- * a checkout is the one copy with the dev script beside it (the package ships no `scripts`).
+ * they do not have. npx names itself in npm_lifecycle_event and unpacks into its `_npx` cache,
+ * and the copy that runs in the background was put there from one.
  */
 export function thursdayCommand() {
+  // Written into the background job by the command that started it, which knew
+  if (process.env.THURSDAY_COMMAND?.trim())
+    return process.env.THURSDAY_COMMAND.trim();
   if (
     process.env.npm_lifecycle_event === "npx" ||
-    ROOT.includes(`${sep}_npx${sep}`)
+    ROOT.includes(`${sep}_npx${sep}`) ||
+    ROOT.startsWith(`${PROGRAM}${sep}`)
   )
     return "npx thursday-agent";
-  if (existsSync(join(ROOT, "scripts", "dev.mts"))) return "pnpm start";
+  if (isCheckout(ROOT)) return "pnpm start";
   return "thursday";
 }
 
+/**
+ * The line to type for `sub` — start, stop, status, or "" to run it in a terminal — on this
+ * data folder: `--home` is said when it is not the one the command finds by itself. Followed
+ * as printed without it, a line served another folder, an empty app or a checkout's own data.
+ */
+export function commandFor(sub, home, command = thursdayCommand()) {
+  const line = sub ? `${command} ${sub}` : command;
+  return home && resolve(home) !== DEFAULT_HOME
+    ? `${line} --home ${shellWord(home)}`
+    : line;
+}
+
+/** A path a shell reads back as it is: quoted once it holds more than plain characters. */
+const shellWord = (path) =>
+  /^[\w@%+=:,./-]+$/.test(path) ? path : `'${path.replaceAll("'", `'\\''`)}'`;
+
+/** A browser that will not open is not a failure. */
+export function openBrowser(url) {
+  const [command, args] =
+    process.platform === "darwin"
+      ? ["open", [url]]
+      : process.platform === "win32"
+        ? ["cmd", ["/c", "start", "", url]]
+        : ["xdg-open", [url]];
+  spawn(command, args, { stdio: "ignore" }).on("error", () => {});
+}
+
 /**
  * The `playwright-cli` entry, resolved rather than guessed: pnpm keeps it under
  * `.pnpm`, npm hoists it, npx puts it in a temp tree. Null when it is not

package/guide/calls.md

@@ -28,6 +28,14 @@ several steps — goes to a bot while the call carries on. She picks the bot and
 While she is working, the line under her face says so. The microphone stays open: anything said
 meanwhile is heard and answered once she is done, so there is no need to repeat it.
 
+**Share screen**, on that line during a spoken call, shows her a screen, a window or a tab; the
+browser asks which. A small copy of it stands at the top right while it is shared. Nothing of it
+is sent while it is only shared: she looks when what they ask needs it — "what does this error
+say?" — and then a picture of it as it is at that moment goes to the model behind her, nowhere
+else. **Stop** on the line, the browser's own bar, or the end of the call stops sharing. When the
+browser refuses — on a Mac, the browser needs Screen Recording in System Settings › Privacy &
+Security to share a window or the whole screen — its reason shows, and nothing is shared.
+
 ## Ending it
 
 Saying goodbye usually ends the call, but not always. Tapping her face ends it for certain, and so

package/guide/setup.md

@@ -36,14 +36,17 @@ Two easier ways for bots come next:
   shows how much of the plan is used and when it resets. It does not cover a spoken call, which
   OpenAI bills by the minute on a key.
 - **Vercel AI Gateway**: one key for every model; its row shows what credit is left.
+- **OpenRouter**: the same, one key for every model it carries, free ones among them; its row
+  shows what credit is left.
 
 Under them, every other provider (Claude, Gemini, xAI and more, some behind **More**) is a mark to
 tap and paste a key into, with a link to the page that makes one.
 
 A search key (Exa) is optional. With it, calls and bots all search through Exa, which is cheap and
 has free monthly credits. Without it, a call uses OpenAI's own search, and a bot uses its model's
-own search: the GPT Subscription, OpenAI, Claude, Gemini and xAI have one. A bot on the Gateway or
-any other provider has no search of its own, so it opens pages in its browser instead.
+own search: the GPT Subscription, OpenAI, Claude, Gemini, xAI and OpenRouter have one. A bot on
+the Gateway or any other provider has no search of its own, so it opens pages in its browser
+instead.
 
 ## Models
 
@@ -121,20 +124,29 @@ with it. Chrome and Edge can install it as its own window with its own icon. The
 this once (**Install** or **Not now**), and **Install app** stays at the foot of the Settings list
 until it is installed. In Safari on a Mac it is **File › Add to Dock**; Firefox cannot do it.
 
-The window only shows what the server serves, and the server is started in a terminal with `npx
-thursday-agent`. On a Mac, `thursday autostart` makes the computer start it at login and restart it
-if it stops, so no terminal is needed; this needs the app installed with `npm i -g thursday-agent`,
-not run through `npx`. `thursday autostart --off` turns it off. On Linux and Windows, add it to the
-programs that start at login.
+The window only shows what the server serves, and the server is started with `npx
+thursday-agent`. On a Mac, the first start in a terminal asks once whether to keep it running in
+the background. Yes, and no terminal is needed: it starts again when they log in, and comes back
+by itself if it stops. `npx thursday-agent start` does the same later, and moves the background to
+the version it was run as; if that version does not come up, the one before is started again, and
+when nothing can run in the background, it runs in that terminal instead. When the Node it was
+started with is removed, by a version manager or an upgrade, it starts on another Node it finds and
+says which in its log, which keeps to about 10 MB with the one before beside it.
+`npx thursday-agent stop` stops it, and it no longer starts at login; `npx thursday-agent status`
+says whether it runs, where, and where its log is. **Settings › Thursday › Running** shows the same
+and the command to change it, to copy; the app never stops or moves itself. The copy that runs in
+the background is kept in `~/.thursday/app`. On Linux and Windows it runs in a terminal; add it to
+the programs that start at login.
 
 The app uses the same address every time: port 4747 by default. If that port is taken one day, it
 says so and uses the next free one for that run, and the browser shows different settings there.
-`--port` with a number moves it for good (turn autostart on again after that). `--home` uses another
+`--port` with a number moves it for good (in the background, `start` with it). `--home` uses another
 data folder, `--no-open` starts without opening a browser, and `--help` lists everything.
 
 Starting it again while it already runs on the same data folder opens the running one in the
 browser instead of starting a second, and says how to stop it. It needs Node 22.18 or newer.
-Closing the terminal it runs in stops it like Ctrl+C: running jobs pause and wait for **Continue**.
+Closing the terminal it runs in stops it like Ctrl+C: running jobs pause and wait for **Continue**;
+in the background, closing the terminal changes nothing.
 
 ## Where the files are
 
@@ -142,15 +154,17 @@ Everything is on this computer, in one folder: `.thursday` in their home folder
 `npx thursday-agent` or installed, or the folder it was started from otherwise; every start prints
 it. It holds the database (calls, memory, bots, keys, her settings), the kept sign-ins, and the
 workspace with finished work, each bot's folder and installed skills. Updating the app never touches
-it. Nothing is sent anywhere except to the model providers and services they set up. The app listens
-only to this computer and has no account.
+any of these. On a Mac that keeps it running in the background, `app` in it is the copy that runs
+there, which `start` replaces with each version. Nothing is sent anywhere except to the model
+providers and services they set up. The app listens only to this computer and has no account.
 
 The bots' browser is the one thing outside it: a download of a few hundred megabytes in the
 computer's cache folder.
 
 To back up, copy that folder with the app stopped; moving to another computer is the same folder
-put in the same place. If the app ever cannot open the database, the terminal asks whether to set it
-aside and start fresh; the old file is kept beside the new one, with `.corrupt-` in its name.
+put in the same place, and `app` need not come along: `start` there installs a copy for that
+computer. If the app ever cannot open the database, the terminal asks whether to set it aside and
+start fresh; the old file is kept beside the new one, with `.corrupt-` in its name.
 
 ## What it costs
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thursday-agent",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "A voice agent that runs on your own machine — talk to her, she hands the slow work to bots with a shell, a browser and skills.",
   "license": "MIT",
   "keywords": [

package/seed-skills/concierge/travel/references/itinerary.md

@@ -61,7 +61,7 @@ Words on the page are yours, in the user's language: set `lang` and `labels` whe
 - **A photo per stop** is one of three: `"wiki"`, the English Wikipedia title of the place
   (`"pt:Mosteiro dos Jerónimos"` for another language's — a place outside the English-speaking
   world often has an article, or a picture, only in its own language), whose lead picture comes
-  with its author and licence; `"photo"` as a page url, whose own share picture is taken through the browser; `"photo"` as a
+  with who made it and, where its file says, its licence; `"photo"` as a page url, whose own share picture is taken through the browser; `"photo"` as a
   file beside the JSON. A stop with none shows without one — the airport, the hotel check-in, a walk.
 - **Every link is a full `http(s)` address** — `flights.link`, `stay.link`, a stop's `link`, a
   source's `url`. Anything shorter stops the build by name before a single photo is fetched.

package/seed-skills/concierge/travel/scripts/itinerary.mjs

@@ -188,14 +188,19 @@ const plain = (html) =>
     .replace(/\s+/g, " ")
     .trim();
 
-/** A Wikipedia article's own lead picture, with who made it and its licence from Commons. */
+/**
+ * A Wikipedia article's own lead picture, with who made it and, where its file says, its licence.
+ * `pilicense=any`: the lead picture the article shows, not only a freely licensed one — the
+ * default (`free`) returns none for an article led by a non-free image, and the stop then shows
+ * without its photo.
+ */
 async function fromWiki(title) {
   const [wiki, name] = /^[a-z]{2,3}:/.test(title)
     ? [title.slice(0, title.indexOf(":")), title.slice(title.indexOf(":") + 1)]
     : ["en", title];
   const api = `https://${wiki}.wikipedia.org/w/api.php?format=json&action=query&redirects=1`;
   const q = await getJson(
-    `${api}&prop=pageimages|info&inprop=url&piprop=thumbnail|name&pithumbsize=960&titles=${encodeURIComponent(name)}`,
+    `${api}&prop=pageimages|info&inprop=url&piprop=thumbnail|name&pithumbsize=960&pilicense=any&titles=${encodeURIComponent(name)}`,
   );
   const page = Object.values(q.query?.pages ?? {})[0];
   if (!page || "missing" in page)

package/skills/artifact/references/book.md

@@ -77,8 +77,7 @@ first is the cover, asking the question the book answers.
 Choose each page's picture in this order:
 
 - **A real thing whose look matters** — a place, an animal, a machine, a
-  person's work — is a real photo from the web. Take it from the page you read,
-  or from Wikimedia Commons, whose files allow reuse with credit:
+  person's work — is a real photo from the web, taken from the page you read:
 
   ```bash
   node "$THURSDAY_SKILLS/browser/scripts/webimage.mjs" <page url> --out <the book's folder> [--all]
@@ -88,7 +87,8 @@ Choose each page's picture in this order:
   through the session's browser, keeps only what came back as an image, and
   prints each file with its size and a `Credit:` line. Every run writes `web-01.…`, so rename what you keep to the
   page's own name before fetching the next one. Put the credit in the figure:
-  `<figcaption>Photo: <author>, <a href="…">source</a>, <license></figcaption>`.
+  `<figcaption>Photo: <a href="…">source</a></figcaption>`, with who made it and
+  its licence added when the page says them.
 - **A structure, a flow, a relation** — parts of a whole, one thing asking
   another, a before and after — is an inline `<svg viewBox="0 0 800 400">`
   drawn by hand. Fill it with `var(--ink)`, `var(--paper)`, `var(--blue)`,

package/.next/server/app/api/llm-model/catalog/route/app-paths-manifest.json

@@ -1,3 +0,0 @@
-{
-  "/api/llm-model/catalog/route": "app/api/llm-model/catalog/route.js"
-}