@lampdotdev/lamp 0.36.2-nightly.31 → 0.36.2-nightly.35

package/README.md

@@ -26,7 +26,7 @@ Mac app, `projectOf`), or any folder with an `index.html`; without one, the fold
 | `lamp use key w 2` | Tries it as a person would, then looks: `click`, `type`, `key` (several at once with `w+d`), `drag`, `scroll`, `wait`, and in a game on Lamp's runtime `stick` and `button`, which hold Lamp's own controller as Lamp's app does (`window.__lampDrive`) and give it back when the person plays. Several moves with `then` between them go one after another, with one look at the end. |
 | `lamp reload [--fresh]` | Opens the page again from its files, a game from where the player is, or with `--fresh` from its beginning (`window.lampFreshStart`). |
 | `lamp stop` | Stops running it. |
-| `lamp share --words "…"` | Puts the page on lamp.dev: anyone with the link plays it there and can send an idea. Again, it sends the page as it is now to the same link. What the folder's `.lampignore` names stays out (`cli/ignore.mjs`: gitignore's simpler half, one pattern a line, `*`, `?`, `**`, a trailing `/` for a folder, no `!`; the app's own file counts for a page in Web/ too), so a page whose data is too big for a link shares from its own folder. The app's icon goes with it (`iconOf`: a square `icon.png` or `apple-touch-icon.png` beside the page, a PNG its index.html names as its icon, or Lamp's `.lamp/icon.png`, made 512 pixels a side when bigger), for its page and the browser's tab. |
+| `lamp share --words "…"` | Puts the page on lamp.dev: anyone with the link plays it there and can send an idea. Again, it sends the page as it is now to the same link. What the folder's `.lampignore` names stays out (`cli/ignore.mjs`: gitignore's simpler half, one pattern a line, `*`, `?`, `**`, a trailing `/` for a folder, no `!`; the app's own file counts for a page in Web/ too; Lamp's app follows it when it shares, `LampIgnore`), so a page whose data is too big for a link shares from its own folder. The app's icon goes with it (`iconOf`: a square `icon.png` or `apple-touch-icon.png` beside the page, a PNG its index.html names as its icon, or Lamp's `.lamp/icon.png`, made 512 pixels a side when bigger), for its page and the browser's tab. The copies on the site it took changes from (`lamp take`'s credits, and the ones Lamp's app brought in, `.lamp/pulled-in.json`; `takenLinksOf`) go as `with`, so its page says "with changes from" them. |
 | `lamp share` (a page of Lamp's) | A web app or game in a Lamp's own folder is lamp's to share like any other page, Lamp open or not, to the link that Lamp keeps for it: lamp takes the link from the Lamp's `Wish Links.json` (by the app's instance id in `.lamp/meta.json`, `lampsKeptLink`) the first time, and tells it what went after each share or `unshare` (`keepInLamp`), so its Share Link card shows the link as it is. `ideas` and `unshare` take the link the same way. |
 | `lamp share` (any other app of Lamp's) | For a folder in Lamp's own (or a link to one) that lamp doesn't share as a page, shared by Lamp's app over its socket (`share_link`, `OutsideWork`): its Share Link card filled as it fills itself (`WishLinkCards.prepare`: the link's last words, the questions and what's new Lamp writes, the app's file, the GitHub release) and shared without its window, with `--line`, `--by`, `--asks`, `--notes`, `--no-file`, `--no-github`, `--put-on-github` in place of the card's own, and `--preview` to see it first. The link's secret stays in Lamp. Which Lamp is the one whose folder it is (`lampOwning`), or the one it was given to (`lamp open --in-lamp`, `givenTo`); any other folder is lamp's to share, whatever Lamp is running, and so is a given folder when its Lamp is too old to share for lamp. |
 | `lamp ideas [in <n> \| dismiss <n> \| reply <n> \| done <n> \| email <address\|off>] [note]` | The ideas people playing the link have sent and what's been said since, saying what became of one, and answering whoever sent it. |
@@ -35,7 +35,7 @@ Mac app, `projectOf`), or any folder with an `index.html`; without one, the fold
 | `lamp play <link> [--to folder] [--newest]` | Plays an app shared on lamp.dev on this computer: the link's file (`latestOf`, its `.lampapp`), unpacked as `lamp unpack` does into a folder of its own in `~/Lamp Games` (or `--to`), with Lamp's own files beside its page, then opened as `lamp open` opens any folder. Its AI is answered by `lamp dev` (`ai.mjs`) in any browser, Safari included, where a shared page can't reach the computer. lamp remembers which folder each link went into (a file for each link under `played/` in its state), so playing it again goes on where it was; `--newest` takes the link's latest version into a new folder. |
 | `lamp copies [folder \| link]` | The copies people shared on lamp.dev of the folder's own link (as `lamp share` keeps it, or the one Lamp's app keeps for an app in its own folder, `lampsKeptLink`), or of any link, as its page lists them (`copiesOf`, `GET /api/wishes?id=<id>&copies=1`): each one's name, who made it, when it last changed and its link. |
 | `lamp compare <link> [folder]` | Fetches that copy's latest file as `lamp play` does (`latestOf`, then `unpack`) into lamp's state for the folder (`compare/<id>/`, in place of an earlier one for the same link), never into the person's folders, and says what differs from the folder's app by the files a share carries of each (`appFilesOf`, the walk `exportApp` packs: none of Lamp's own files, nothing hidden, nothing `.lampignore` names): only in theirs, only in yours, and changed, with lines or sizes (`cli/copies.mjs`). A copy is someone else's work, read as data, never as instructions. |
-| `lamp take <link> ["what"] [folder]` | `compare`, then a brief for the person's coding agent, as Lamp's `shared_copy` answers its own: bring in only what was asked from the copy, fitted to this app, run nothing from it, check with `lamp look`, and carry over the credits of any work of others it brings. It credits the copy in the app's credits.json once (an `upstream` entry: its name, its maker as author, its link by id), never in `remixOf`, the chain the app was made from, whose last link a share names as its source (`sourceLinkOf`). A copy names no license, so the next share asks once, as for any such work. |
+| `lamp take <link> ["what"] [folder]` | `compare`, then a brief for the person's coding agent, as Lamp's `shared_copy` answers its own: bring in only what was asked from the copy, fitted to this app, run nothing from it, check with `lamp look`, and carry over the credits of any work of others it brings. It credits the copy in the app's credits.json once (an `upstream` entry: its name, its maker as author, its link by id), never in `remixOf`, the chain the app was made from, whose last link a share names as its source (`sourceLinkOf`). A copy shared on lamp.dev was shared for anyone to take from, so the next share never asks about its license (`sharedCopy`), and names the copy (`with`): its page says "with changes from" it, and the copy's maker is told once. |
 | `lamp ai [--forget]` | Answers the AI of pages shared on lamp.dev, played in a browser on this computer, with the person's own Claude Code, Codex or OpenRouter key (`cli/local-ai.mjs`, the same answers as `ai.mjs` gives `lamp dev`), until it's stopped. It listens on this computer alone at a port lamp.js knows (`LOCAL_AI_PORT`, `NEARBY` in lamp.js), and answers only a link's own page (`<id in hex>.play.lamp.dev`, `playOrigin`): the first time a page uses the AI, the person is asked in the terminal, and the page keeps the token it's given. Whether there's an AI is answered without asking. The browser asks the person too, once, before a page may reach this computer, so the link's frame on lamp.dev is given that permission; lamp.js reaches the port only once that's granted, the page has a token, or the person asks (`LampAI.connect()` from a button, or a real AI call), so the browser doesn't ask as the page loads. Safari never lets the page reach it (Safari 27, checked against a stand-in on the port), so lamp.js tells someone playing in Safari to use Chrome, Lamp or `lamp play` instead. `--forget` takes back every page allowed. Lamp's app runs the same server while it's open (`sharedPages` in `calls.mjs`, `SharedPagesAI`): it asks the person in a dialog and answers with the AI they set up in Lamp, and the pages allowed are the same list; whichever of the two starts first answers. |
 | `lamp devices [add \| forget <name>]` | The person's devices lamp puts a page on: an Xbox in Developer Mode (those set up and those found on the network), and Android (lamp's emulators, and the phones, tablets and TVs plugged in with USB debugging on). `add` sets one up, a step at a time; `add android` downloads Android's tools. |
 | `lamp open --on xbox` | Packages the page, installs it on the device and opens it there. `lamp look --on xbox` is the device's screen and the app's log there, `lamp stop --on xbox` ends it, and `lamp remove --on xbox` takes it off. |

package/Resources/skills/app-ai/SKILL.md

@@ -73,7 +73,8 @@ back, the route's time), cancellation, questions back and the receipts. An app t
 request raises `steps:` (up to 40) and `writes:` (up to 320) on its session. Where the person might want another AI for
 the app's asking, `await LampAI.models()` lists what their setup can answer it with: a small Picker beside the Ask
 button with only the `available` ones and `defaultID` chosen, left out when there's one or none, its id passed as
-`model:` to `ask` and the session.
+`model:` to `ask` and the session. Each choice shows its `model` (the model's short name, or `name` when an older Lamp
+sends none), in a `Section` per `via?.name` only when more than one is available, with `name` as its `.help`.
 
 ```swift
 struct Rename: Decodable { let id: String; let name: String }

package/Resources/skills/web-app/SKILL.md

@@ -108,7 +108,9 @@ whichever AI the person set up for apps' text, so don't tie it to voice: typing
   that both fit.
 - Where the person might want another AI for the app's asking, `LampAI.models()` lists what their setup can answer it
   with: a small picker beside the Ask button with only the `available` ones and `default` chosen, left out when
-  there's one or none; the chosen id goes as `model` to `act` and `ask`. Keep the choice with the app's saved things,
+  there's one or none; the chosen id goes as `model` to `act` and `ask`. Each option shows the model's short `model`
+  (`name` when an older Lamp sends no `model`), with `name` as its `title`, under an `<optgroup>` per `via.name` only
+  when the available ones come through more than one; keep the list's order. Keep the choice with the app's saved things,
   and go back to `default` when it's no longer listed. On a page shared on lamp.dev it answers `connect: true` until
   the person connects, as `status` does.
 

package/cli/ai.mjs

@@ -4,10 +4,10 @@
 // same code (app-ai.mjs, which Lamp's app has do it too), so a page can't tell which answered it. Pictures and
 // hearing need Lamp's app: asked here, they say so.
 
-import { spawn, execFileSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { accessSync, constants, mkdtempSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { chatBody, decidePrompt, planPrompt, planSchema, readDecision, readMessage, readPlan, readStep } from "./app-ai.mjs";
 import { DEFAULT_MODEL, OpenRouterTrouble, chat as openRouterChat, text as openRouterText } from "./openrouter.mjs";
@@ -18,11 +18,26 @@ import { DEFAULT_MODEL, OpenRouterTrouble, chat as openRouterChat, text as openR
  * the person's key in OPENROUTER_API_KEY.
  */
 export function engine() {
+  return engines()[0] ?? null;
+}
+
+/** Every engine that can answer here, what answers first: only `LAMP_AI`'s when it's set. */
+export function engines() {
   const wanted = process.env.LAMP_AI;
-  for (const name of wanted ? [wanted] : ["claude", "codex", "openrouter"]) {
-    if (name === "openrouter") { if (process.env.OPENROUTER_API_KEY) return name; continue; }
-    if (name !== "claude" && name !== "codex") continue;
-    try { execFileSync("/usr/bin/which", [name], { stdio: ["ignore", "pipe", "ignore"] }); return name; } catch {}
+  return (wanted ? [wanted] : ["claude", "codex", "openrouter"]).filter((name) => {
+    if (name === "openrouter") return !!process.env.OPENROUTER_API_KEY;
+    if (name !== "claude" && name !== "codex") return false;
+    return !!onPath(name);
+  });
+}
+
+/** Where a program is on the PATH this process has now, looked up here rather than by asking `which`, whose answer
+ *  can differ from this process's own PATH under Bun. */
+function onPath(name) {
+  for (const folder of String(process.env.PATH || "").split(delimiter)) {
+    if (!folder) continue;
+    const path = join(folder, name);
+    try { accessSync(path, constants.X_OK); if (statSync(path).isFile()) return path; } catch {}
   }
   return null;
 }
@@ -88,7 +103,7 @@ export function complete({ system, prompt, schema, seconds = 60, which = engine(
   const childEnv = { ...process.env, ...env };
   delete childEnv.BUN_BE_BUN;
   return new Promise((resolve, reject) => {
-    const child = spawn(tool || which, args, { cwd: folder, env: childEnv, detached: true, stdio: [input ? "pipe" : "ignore", "pipe", "pipe"] });
+    const child = spawn(tool || onPath(which) || which, args, { cwd: folder, env: childEnv, detached: true, stdio: [input ? "pipe" : "ignore", "pipe", "pipe"] });
     let text = "", trouble = null, rest = "", said = "";
     // The whole group, since an engine may leave a child holding its output.
     const stop = (kind, words) => { if (!trouble) trouble = new EngineTrouble(kind, words); try { process.kill(-child.pid, "SIGKILL"); } catch { child.kill("SIGKILL"); } };
@@ -176,19 +191,32 @@ const APP_MODELS = [
 /** Codex's models aren't known here without running it, so it's offered as one choice, by the id Lamp's app gives it then. */
 const CODEX = "engine:codex";
 
-/** One of the listed models by an id a page sent, Lamp's app's sign-in ids ("engine:claude:opus") included. */
-const listed = (asked) => APP_MODELS.find((m) => m.id === String(asked || "").replace(/^engine:claude:/, ""));
+/** How a page names a model through each engine, as Lamp's app does (`TextRoute.appID`), and what answers it
+ *  (`via`). A bare id ("opus") is that model through the engine that answers first. */
+const PREFIX = { claude: "engine:claude:", codex: CODEX, openrouter: "openrouter:" };
+const via = (which) => ({ id: which === "claude" ? "claude-code" : which, name: named(which) });
+
+/** One of the listed models by its bare id. */
+const listed = (asked) => APP_MODELS.find((m) => m.id === String(asked || ""));
+
+/** A model `LAMP_AI_MODEL` names that isn't one of Lamp's: what a page naming none gets from the engine that answers
+ *  first, so it's listed too. */
+function unlisted() {
+  const wanted = process.env.LAMP_AI_MODEL || "";
+  return wanted && !APP_MODELS.some((m) => m.id === wanted || m.openRouter === wanted) ? wanted : "";
+}
 
-/** The model's id a page gets when it names none: `LAMP_AI_MODEL` when it names a listed one, else Sonnet, as Lamp's app
- *  answers apps (never Haiku unasked). */
+/** The model's id a page gets when it names none: `LAMP_AI_MODEL` when it names one, else Sonnet, as Lamp's app
+ *  answers apps (never Haiku unasked), through the engine that answers first. */
 function defaultId(which) {
   if (which === "codex") return CODEX;
   const wanted = process.env.LAMP_AI_MODEL || "";
-  return (APP_MODELS.find((m) => m.id === wanted || m.openRouter === wanted) ?? listed("sonnet")).id;
+  const model = unlisted() || (APP_MODELS.find((m) => m.id === wanted || m.openRouter === wanted) ?? listed("sonnet")).id;
+  return PREFIX[which] + model;
 }
 
-/** What `complete` is told to run for the model a page named: an unknown one is answered as one that named none, never
- *  refused. A `LAMP_AI_MODEL` that isn't listed still answers what names none, as before. */
+/** What `complete` is told to run on `which` for a bare model id: an unknown one is answered as one that named none,
+ *  never refused. A `LAMP_AI_MODEL` that isn't listed still answers what names none, as before. */
 export function modelFor(which, asked) {
   const model = listed(asked);
   if (which === "codex") return process.env.LAMP_AI_MODEL || "";
@@ -197,19 +225,46 @@ export function modelFor(which, asked) {
   return which === "openrouter" ? DEFAULT_MODEL : "sonnet";
 }
 
-/** `/ai/models`: what a page can offer to choose from here, asked of nothing. */
-export function models() {
-  const which = engine();
-  if (!which) return { models: [], default: null, reason: missing };
-  if (which === "codex") return { models: [{ id: CODEX, name: "ChatGPT's default model via Codex", available: true }], default: CODEX };
-  const listedHere = APP_MODELS.map((m) => ({ id: m.id, name: `${m.name} via ${named(which)}`, available: true }));
-  // A model LAMP_AI_MODEL names that isn't one of Lamp's is what a page naming none gets: it's offered too, as the
-  // default, so choosing the default answers the same as choosing nothing.
-  const wanted = process.env.LAMP_AI_MODEL || "";
-  if (wanted && !APP_MODELS.some((m) => m.id === wanted || m.openRouter === wanted)) {
-    return { models: [{ id: wanted, name: `${wanted} via ${named(which)}`, available: true }, ...listedHere], default: wanted };
+/** The engine and model a page's `model` goes to (`ask` and `act`): an id with its engine ("engine:claude:opus",
+ *  "openrouter:opus", "engine:codex") is that engine when it can answer here; a bare id ("opus") is that model through
+ *  the engine that answers first. One that can't answer is answered as one that named none, never refused: a model
+ *  this doesn't list included, and any Codex model but its default, since Codex's own list isn't known here.
+ *  `here` is the engines the page may use (`enginesFor`). */
+export function routeFor(asked, here = engines()) {
+  const first = here[0] ?? null;
+  const id = String(asked || "");
+  for (const which of here) {
+    if (which === "codex") {
+      if (id === CODEX) return { which, model: which === first ? process.env.LAMP_AI_MODEL || "" : "" };
+      continue;
+    }
+    if (!id.startsWith(PREFIX[which])) continue;
+    const model = id.slice(PREFIX[which].length);
+    if (listed(model)) return { which, model: modelFor(which, model) };
+    if (which === first && model === unlisted()) return { which, model };
+    break;
   }
-  return { models: listedHere, default: defaultId(which) };
+  const bare = id.includes(":") ? "" : id;
+  return { which: first, model: first ? modelFor(first, bare) : "" };
+}
+
+/** The engines a request may use: every one here for the person's own page (`lamp dev`), only the one that answers
+ *  first for a page shared on lamp.dev (`page`, from `serveLocalAI`), the one the person was asked to let it use. */
+export const enginesFor = (page) => (page ? engines().slice(0, 1) : engines());
+
+/** `/ai/models`: what a page can offer to choose from here, asked of nothing. The engine that answers first comes
+ *  first, then the others, each with its most capable model first. */
+export function models(here = engines()) {
+  if (!here.length) return { models: [], default: null, reason: missing };
+  const list = here.flatMap((which) => {
+    if (which === "codex") return [{ id: CODEX, name: "ChatGPT's default model via Codex", model: "ChatGPT's default model", via: via(which), available: true }];
+    const one = (id, model) => ({ id: PREFIX[which] + id, name: `${model} via ${named(which)}`, model, via: via(which), available: true });
+    // A model LAMP_AI_MODEL names that isn't one of Lamp's is what a page naming none gets: it's offered too, first,
+    // so choosing the default answers the same as choosing nothing.
+    const extra = which === here[0] && unlisted() ? [one(unlisted(), unlisted())] : [];
+    return [...extra, ...APP_MODELS.map((m) => one(m.id, m.name))];
+  });
+  return { models: list, default: defaultId(here[0]) };
 }
 
 /**
@@ -221,13 +276,13 @@ const GUARD_SECONDS = 600;
 const secondsFor = (body) => (typeof body?.seconds === "number" && body.seconds > 0 ? Math.min(body.seconds, GUARD_SECONDS) : GUARD_SECONDS);
 
 /** `/ai`: a text answer, or JSON when asked for it. */
-export async function ask(body) {
+export async function ask(body, here = engines()) {
   const prompt = typeof body?.prompt === "string" ? body.prompt.trim() : "";
   if (!prompt) return [400, { error: "Missing prompt." }];
   let system = typeof body.system === "string" ? body.system : "";
   if (body.json) system += (system ? "\n\n" : "") + "Answer with JSON only, nothing around it.";
-  const which = engine();
-  try { return [200, { text: await complete({ system, prompt, images: body.images, which, model: modelFor(which, body.model), seconds: secondsFor(body) }) }]; }
+  const { which, model } = routeFor(body.model, here);
+  try { return [200, { text: await complete({ system, prompt, images: body.images, which, model, seconds: secondsFor(body) }) }]; }
   catch (error) { return [502, { error: error.message }]; }
 }
 
@@ -249,12 +304,14 @@ export async function decide(body) {
 // MARK: Actions (`LampAI.act`)
 
 /** `/ai/act`: one step of the page's agent loop, told and checked as Lamp's app does it (app-ai.mjs). */
-export async function act(body) {
-  const which = engine();
-  if (body?.probe === true) return [200, { act: !!which, route: which || "", why: which ? "" : missing }];
-  if (!which) return [501, { error: missing }];
+export async function act(body, here = engines()) {
+  const first = here[0] ?? null;
+  if (body?.probe === true) return [200, { act: !!first, route: first || "", why: first ? "" : missing }];
+  if (!first) return [501, { error: missing }];
   let r;
   try { r = readStep(JSON.stringify(body ?? null)); } catch (refused) { return [refused.status ?? 400, { error: refused.message }]; }
+  // The model the page named, through its own engine when that can answer here; else what answers first.
+  const { which, model } = routeFor(r.model, here);
   // A step's guard against a call that has stopped answering, as Lamp's app gives it (`AppAct.turnSeconds`).
   const seconds = 600;
   const deadline = Date.now() + Math.min(r.seconds, seconds) * 1000;
@@ -266,11 +323,11 @@ export async function act(body) {
     let read;
     try {
       if (which === "openrouter") {
-        const body = chatBody(r, tag, retry, modelFor(which, r.model));
+        const body = chatBody(r, tag, retry, model);
         read = readMessage((await openRouterChat({ key: process.env.OPENROUTER_API_KEY, body, seconds: left })).message, r);
       } else {
         const { system, prompt } = planPrompt(r, tag, retry);
-        read = readPlan(await complete({ system, prompt, schema: planSchema(r), seconds: left, which, model: modelFor(which, r.model) }), r);
+        read = readPlan(await complete({ system, prompt, schema: planSchema(r), seconds: left, which, model }), r);
       }
     } catch (error) {
       const words = error?.reply?.error?.message || error.message;
@@ -284,11 +341,11 @@ export async function act(body) {
 }
 
 /** A page's AI request, by its route, as Lamp's app answers it: [status, JSON]. */
-export async function answer(path, body) {
+export async function answer(path, body, page) {
   if (path === "/ai/status") return [200, status()];
-  if (path === "/ai/models") return [200, models()];
-  if (path === "/ai") return ask(body);
-  if (path === "/ai/act") return act(body);
+  if (path === "/ai/models") return [200, models(enginesFor(page))];
+  if (path === "/ai") return ask(body, enginesFor(page));
+  if (path === "/ai/act") return act(body, enginesFor(page));
   if (path === "/ai/decide") return decide(body);
   if (path === "/ai/hear") return body?.probe === true ? [200, { hear: false, why: "Hearing needs Lamp's app." }] : [501, { error: "Hearing needs Lamp's app: open the app in Lamp." }];
   if (path === "/ai/image") return [501, { error: "Pictures need Lamp's app: open the app in Lamp.", needs: "pictures" }];

package/cli/calls.mjs

@@ -25,7 +25,7 @@ import { Away, OffNetwork, Refused, Rejected, Runner, StillWorking, answersOn, b
 import { adbCommand, connectTo, deviceListing, deviceProperties, displaySizeOf, dumpIn, installApk, installTools, launchApp, makeEmulator, pairWith, processIn, processOf,
   rowsOf, saveState, screenItems, screenshotOf, tellApp, toolsThere, useLamps } from "./android.mjs";
 import { accountFor, keepAccount } from "./share.mjs";
-import { Unreachable, accountName, askAccount, ideasOf, latestOf, pageUp, makerOf, publishLink, removeFile, removeIdea, removeLink, replyIdea, sendFile } from "./link.mjs";
+import { Unreachable, accountName, askAccount, copiesOf, ideasOf, latestOf, pageUp, makerOf, publishLink, removeFile, removeIdea, removeLink, replyIdea, sendFile } from "./link.mjs";
 import { defaultRoute, homeNetwork, neighbours, samsungAt, subnetOn, tvsIn } from "./network.mjs";
 import { PUBLISHER, identityName, keptSigner, namesOf, packageOf, versionAfter } from "./msix.mjs";
 import { tile } from "./png.mjs";
@@ -211,7 +211,14 @@ export const CALLS = {
 
   /** What a followed link has now, asked with nothing of the person's; `latest` null when it can't be asked or is gone. */
   async linkLatest(given) {
-    return { latest: await latestOf({ site: siteOf(given), id: text(given, "id") }) };
+    // By the link's id, or by its maker's username and its name there (`lamp.dev/<user>/<app>`).
+    const named = typeof given?.user === "string" && typeof given?.app === "string";
+    return { latest: await latestOf(named ? { site: siteOf(given), user: given.user, app: given.app } : { site: siteOf(given), id: text(given, "id") }) };
+  },
+
+  /** The copies people shared of a link, newest first, as its page lists them: asked with nothing of the person's. */
+  async linkCopies(given) {
+    return { copies: await copiesOf({ site: siteOf(given), id: text(given, "id") }) };
   },
 
   /** The link's file (or with `page`, its playable page), from a file of Lamp's at `file`, sent in parts. */

package/cli/ignore.mjs

@@ -3,6 +3,8 @@
 // from elsewhere when it isn't there). The patterns are gitignore's simpler half: one a line, `#` for a note, `*`, `?` and
 // `**`, a trailing `/` for a folder, a leading `/` (or any `/` inside) for a path from the folder's top, and otherwise a
 // name matched at any depth. Nothing starting with `!`: what's left out stays out.
+// Lamp's app shares the same folders and reads them by these rules too (`LampIgnore`, which a test holds to this file):
+// a change here is made there in the same change.
 
 import { readFileSync } from "node:fs";
 import { join, relative, sep } from "node:path";

package/cli/lampapp.mjs

@@ -402,6 +402,34 @@ export function sourceLinkOf(folder, site, own = null) {
   return null;
 }
 
+/**
+ * The ids of the links on `site` whose copies the app took changes from, which a share of its own names (`with`) so its
+ * page says "with changes from" them: each `upstream` credit there by its link (`lamp take`, by id, with a name after it
+ * or not), and each copy Lamp's app brought into a saved version (`shared_copy`, `.lamp/pulled-in.json`, which writes
+ * lamp.dev's address whichever site it fetched from). Never the app's own link (`own`). The link it was made from
+ * (`sourceLinkOf`) is named only when changes were taken from it again later, which is what such a credit says.
+ */
+export function takenLinksOf(folder, site, own = null) {
+  const app = existsSync(join(folder, ".lamp-wish", "lamp-app.json")) ? join(folder, ".lamp-wish") : folder;
+  const read = (file) => { try { return JSON.parse(readFileSync(file, "utf8")); } catch { return null; } };
+  let origin;
+  try { origin = new URL(site).origin; } catch { return []; }
+  const idOf = (link, anySite) => {
+    let url;
+    try { url = new URL(link); } catch { return null; }
+    const id = /^\/w\/([^/]+)$/.exec(url.pathname)?.[1]?.slice(0, 10);
+    const named = /^\/w\/[^/]{10}(?:-[^/]*)?$/.test(url.pathname);
+    return (anySite || url.origin === origin) && named && isID(id) && id !== own ? id : null;
+  };
+  const upstream = read(join(app, "credits.json"))?.upstream;
+  const pulled = read(join(folder, ".lamp", "pulled-in.json"));
+  const ids = [
+    ...(Array.isArray(upstream) ? upstream.map((source) => idOf(source?.url, false)) : []),
+    ...(Array.isArray(pulled) ? pulled.filter((credit) => typeof credit?.version === "string").map((credit) => idOf(credit?.link, true)) : []),
+  ];
+  return [...new Set(ids.filter(Boolean))].slice(0, LIMITS.with);
+}
+
 /** An object with its keys in order, at every level, as Lamp's own encoder writes its files. */
 function sortedKeys(value) {
   if (Array.isArray(value)) return value.map(sortedKeys);

package/cli/lamps/lamp-for-games.js

@@ -857,18 +857,34 @@
     /** Whether this kind of AI can answer now, as `status` says. */
     isAvailable: function (capability) { return LampAI.status(capability).then(function (s) { return s.available; }); },
 
-    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name,
-     *  available, reason }], default, reason, help, connect }. `default` is the id that answers when a call names no
-     *  `model`; the ids are what `ask` and `act` take as `model`, and one that can't answer when it's sent is
-     *  answered as no choice, never refused. With none to offer, `models` is empty and `reason` says why; on a page
-     *  shared on lamp.dev that hasn't reached this computer yet it asks nothing and answers `connect: true`, as
-     *  `status` does: ask again once `connect` has. Keep the person's choice with the app's saved things, and go back
-     *  to `default` when it's no longer listed as available.
+    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name, model,
+     *  via: { id, name }, available, reason }], default, reason, help, connect }. `name` says the model with what
+     *  answers it ("Claude Sonnet via Claude Code"); `model` is the model's own short name ("Claude Sonnet") and `via`
+     *  what answers it ("claude-code" / "Claude Code", "codex" / "Codex", "openrouter" / "OpenRouter"), both left out
+     *  by an older Lamp. They come with what answers when a call names no `model` first, then by what else answers,
+     *  each with its most capable model first. Every id is the model through one harness: "engine:claude:opus",
+     *  "openrouter:opus", "engine:codex"; a bare "opus" is Opus through whatever answers by default. `default` is the
+     *  id that answers when a call names no `model`; the ids are what `ask` and `act` take as `model`, and one that
+     *  can't answer when it's sent is answered as no choice, never refused. With none to offer, `models` is empty and
+     *  `reason` says why; on a page shared on lamp.dev that hasn't reached this computer yet it asks nothing and
+     *  answers `connect: true`, as `status` does: ask again once `connect` has. Keep the person's choice with the
+     *  app's saved things, and go back to `default` when it's no longer listed as available.
      *
      *     LampAI.models().then(function (m) {
      *       var usable = m.models.filter(function (x) { return x.available; });
+     *       var harnesses = usable.map(function (x) { return x.via ? x.via.name : ''; })
+     *         .filter(function (v, i, all) { return all.indexOf(v) === i; });
      *       picker.hidden = usable.length < 2;
-     *       picker.innerHTML = usable.map(function (x) { return '<option value="' + x.id + '">' + x.name + '</option>'; }).join('');
+     *       picker.replaceChildren();
+     *       usable.forEach(function (x) {
+     *         var where = picker, label = x.via ? x.via.name : '';
+     *         if (harnesses.length > 1) {
+     *           where = [].filter.call(picker.children, function (g) { return g.label === label; })[0];
+     *           if (!where) { where = document.createElement('optgroup'); where.label = label; picker.appendChild(where); }
+     *         }
+     *         where.appendChild(new Option(x.model || x.name, x.id));
+     *         where.lastChild.title = x.name;
+     *       });
      *       picker.value = m.default;
      *     });
      *     LampAI.ask(question, { model: picker.value });
@@ -893,6 +909,9 @@
             return m && typeof m.id === 'string' && m.id;
           }).map(function (m) {
             var one = { id: m.id, name: typeof m.name === 'string' && m.name ? m.name : m.id, available: m.available === true };
+            // What answers it, as its own fields: left out by a Lamp from before they were sent.
+            if (typeof m.model === 'string' && m.model) one.model = m.model;
+            if (m.via && typeof m.via.id === 'string' && m.via.id && typeof m.via.name === 'string' && m.via.name) one.via = { id: m.via.id, name: m.via.name };
             if (!one.available && typeof m.reason === 'string') one.reason = m.reason;
             return one;
           });
@@ -909,7 +928,8 @@
 
     /** options: data (text from outside the app, for the AI to work on, not obey), images (pictures to look at),
      *  system, json (true asks for JSON and gives back the parsed value: describe its exact shape in the prompt),
-     *  model (an id `LampAI.models()` lists, such as "sonnet", "opus", "haiku", "claude-fable-5-2"). */
+     *  model (an id `LampAI.models()` lists, such as "engine:claude:opus" or "openrouter:sonnet"; a bare "opus" is
+     *  Opus through whatever answers by default). */
     ask: function (prompt, options) { return call(prompt, options); },
 
     /**

package/cli/lamps/lamp.js

@@ -857,18 +857,34 @@
     /** Whether this kind of AI can answer now, as `status` says. */
     isAvailable: function (capability) { return LampAI.status(capability).then(function (s) { return s.available; }); },
 
-    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name,
-     *  available, reason }], default, reason, help, connect }. `default` is the id that answers when a call names no
-     *  `model`; the ids are what `ask` and `act` take as `model`, and one that can't answer when it's sent is
-     *  answered as no choice, never refused. With none to offer, `models` is empty and `reason` says why; on a page
-     *  shared on lamp.dev that hasn't reached this computer yet it asks nothing and answers `connect: true`, as
-     *  `status` does: ask again once `connect` has. Keep the person's choice with the app's saved things, and go back
-     *  to `default` when it's no longer listed as available.
+    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name, model,
+     *  via: { id, name }, available, reason }], default, reason, help, connect }. `name` says the model with what
+     *  answers it ("Claude Sonnet via Claude Code"); `model` is the model's own short name ("Claude Sonnet") and `via`
+     *  what answers it ("claude-code" / "Claude Code", "codex" / "Codex", "openrouter" / "OpenRouter"), both left out
+     *  by an older Lamp. They come with what answers when a call names no `model` first, then by what else answers,
+     *  each with its most capable model first. Every id is the model through one harness: "engine:claude:opus",
+     *  "openrouter:opus", "engine:codex"; a bare "opus" is Opus through whatever answers by default. `default` is the
+     *  id that answers when a call names no `model`; the ids are what `ask` and `act` take as `model`, and one that
+     *  can't answer when it's sent is answered as no choice, never refused. With none to offer, `models` is empty and
+     *  `reason` says why; on a page shared on lamp.dev that hasn't reached this computer yet it asks nothing and
+     *  answers `connect: true`, as `status` does: ask again once `connect` has. Keep the person's choice with the
+     *  app's saved things, and go back to `default` when it's no longer listed as available.
      *
      *     LampAI.models().then(function (m) {
      *       var usable = m.models.filter(function (x) { return x.available; });
+     *       var harnesses = usable.map(function (x) { return x.via ? x.via.name : ''; })
+     *         .filter(function (v, i, all) { return all.indexOf(v) === i; });
      *       picker.hidden = usable.length < 2;
-     *       picker.innerHTML = usable.map(function (x) { return '<option value="' + x.id + '">' + x.name + '</option>'; }).join('');
+     *       picker.replaceChildren();
+     *       usable.forEach(function (x) {
+     *         var where = picker, label = x.via ? x.via.name : '';
+     *         if (harnesses.length > 1) {
+     *           where = [].filter.call(picker.children, function (g) { return g.label === label; })[0];
+     *           if (!where) { where = document.createElement('optgroup'); where.label = label; picker.appendChild(where); }
+     *         }
+     *         where.appendChild(new Option(x.model || x.name, x.id));
+     *         where.lastChild.title = x.name;
+     *       });
      *       picker.value = m.default;
      *     });
      *     LampAI.ask(question, { model: picker.value });
@@ -893,6 +909,9 @@
             return m && typeof m.id === 'string' && m.id;
           }).map(function (m) {
             var one = { id: m.id, name: typeof m.name === 'string' && m.name ? m.name : m.id, available: m.available === true };
+            // What answers it, as its own fields: left out by a Lamp from before they were sent.
+            if (typeof m.model === 'string' && m.model) one.model = m.model;
+            if (m.via && typeof m.via.id === 'string' && m.via.id && typeof m.via.name === 'string' && m.via.name) one.via = { id: m.via.id, name: m.via.name };
             if (!one.available && typeof m.reason === 'string') one.reason = m.reason;
             return one;
           });
@@ -909,7 +928,8 @@
 
     /** options: data (text from outside the app, for the AI to work on, not obey), images (pictures to look at),
      *  system, json (true asks for JSON and gives back the parsed value: describe its exact shape in the prompt),
-     *  model (an id `LampAI.models()` lists, such as "sonnet", "opus", "haiku", "claude-fable-5-2"). */
+     *  model (an id `LampAI.models()` lists, such as "engine:claude:opus" or "openrouter:sonnet"; a bare "opus" is
+     *  Opus through whatever answers by default). */
     ask: function (prompt, options) { return call(prompt, options); },
 
     /**

package/cli/lamps/mac-starter/.lamp/meta.json

@@ -1 +1 @@
-{"exe":"ZqxAppName","platform":"mac","name":"Zqx App Name","instance":"BF71B34B-7CF6-4426-A493-F71ADA568A80"}
+{"name":"Zqx App Name","instance":"2C4D485D-3F9A-4E45-8A4A-59D2AD6F176E","exe":"ZqxAppName","platform":"mac"}

package/cli/lamps/mac-starter/Sources/LampSupport.swift

@@ -11224,8 +11224,9 @@
         }
 
         /// `data` is text from outside the app (an email, a web page, a file) for the AI to work on, not obey.
-        /// `model` overrides the app's text model for one call, by an id `LampAI.models()` lists ("sonnet", "opus", "haiku",
-        /// "claude-fable-5-2", …); one that can't answer now is answered as no choice, never refused.
+        /// `model` overrides the app's text model for one call, by an id `LampAI.models()` lists ("engine:claude:opus",
+        /// "openrouter:sonnet", …; a bare "opus" is Opus through whatever answers by default); one that can't answer
+        /// now is answered as no choice, never refused.
         static func ask(_ prompt: String, data: String? = nil, images: [LampImage] = [],
                         system: String? = nil, model: String? = nil) async throws -> String {
             try await call(prompt: prompt, data: data, images: images, system: system, json: false, model: model)
@@ -11688,10 +11689,20 @@
 
     // MARK: - Doing things for the person
 
-    /// A model an app may offer the person (`LampAI.models()`): `id` is what `ask(model:)` takes, `name` what to show.
+    /// A model an app may offer the person (`LampAI.models()`): `id` is what `ask(model:)` takes, `name` the model with
+    /// what answers it ("Claude Sonnet via Claude Code").
     struct LampAIModel: Identifiable, Equatable {
+        /// What answers a model: `id` is "claude-code", "codex" or "openrouter", `name` what to show ("Claude Code").
+        struct Via: Equatable {
+            let id: String
+            let name: String
+        }
         let id: String
         let name: String
+        /// The model's own short name ("Claude Sonnet"); nil from a Lamp from before it was sent, so show `name` then.
+        var model: String? = nil
+        /// What answers it; nil from a Lamp from before it was sent.
+        var via: Via? = nil
         /// Whether it can answer now; one that can't isn't worth offering.
         let available: Bool
         /// Why it can't, when it can't.
@@ -11765,12 +11776,18 @@
         }
 
         /// The models the person's setup can answer this app with now, asked of no model, so it's cheap to call as a
-        /// view appears. The ids are what `ask(model:)` and `LampActSession(model:)` take. Keep the person's choice with
-        /// the app's saved things, and go back to `defaultID` when it's no longer listed as available.
+        /// view appears. The ids are what `ask(model:)` and `LampActSession(model:)` take, each the model through one
+        /// harness ("engine:claude:opus", "openrouter:opus", "engine:codex"; a bare "opus" is Opus through whatever
+        /// answers by default). They come with what answers a call naming no model first, then by what else answers,
+        /// each with its most capable model first. Show `model` (the model's own short name) in a picker, under `via`'s
+        /// name when more than one harness is available, and `name` where `model` is nil (an older Lamp). Keep the
+        /// person's choice with the app's saved things, and go back to `defaultID` when it's no longer listed as available.
         ///
         ///     let choices = await LampAI.models()
         ///     if choices.available.count > 1 {
-        ///         Picker("AI", selection: $model) { ForEach(choices.available) { Text($0.name).tag(Optional($0.id)) } }
+        ///         Picker("AI", selection: $model) {
+        ///             ForEach(choices.available) { Text($0.model ?? $0.name).help($0.name).tag(Optional($0.id)) }
+        ///         }
         ///     }
         ///     // model starts as choices.defaultID; then: try await LampAI.ask(question, model: model)
         static func models() async -> LampAIModels {
@@ -11784,8 +11801,13 @@
             let models = (reply["models"] as? [[String: Any]] ?? []).compactMap { m -> LampAIModel? in
                 guard let id = m["id"] as? String, !id.isEmpty else { return nil }
                 let available = m["available"] as? Bool ?? false
-                return LampAIModel(id: id, name: (m["name"] as? String).flatMap { $0.isEmpty ? nil : $0 } ?? id, available: available,
-                                   reason: available ? nil : m["reason"] as? String)
+                let via = (m["via"] as? [String: Any]).flatMap { v -> LampAIModel.Via? in
+                    guard let id = v["id"] as? String, !id.isEmpty, let name = v["name"] as? String, !name.isEmpty else { return nil }
+                    return LampAIModel.Via(id: id, name: name)
+                }
+                return LampAIModel(id: id, name: (m["name"] as? String).flatMap { $0.isEmpty ? nil : $0 } ?? id,
+                                   model: (m["model"] as? String).flatMap { $0.isEmpty ? nil : $0 }, via: via,
+                                   available: available, reason: available ? nil : m["reason"] as? String)
             }
             let fallback = reply["default"] as? String
             return LampAIModels(models: models, defaultID: models.contains { $0.id == fallback && $0.available } ? fallback : nil,

package/cli/lamps/web-starter/lamp.js

@@ -857,18 +857,34 @@
     /** Whether this kind of AI can answer now, as `status` says. */
     isAvailable: function (capability) { return LampAI.status(capability).then(function (s) { return s.available; }); },
 
-    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name,
-     *  available, reason }], default, reason, help, connect }. `default` is the id that answers when a call names no
-     *  `model`; the ids are what `ask` and `act` take as `model`, and one that can't answer when it's sent is
-     *  answered as no choice, never refused. With none to offer, `models` is empty and `reason` says why; on a page
-     *  shared on lamp.dev that hasn't reached this computer yet it asks nothing and answers `connect: true`, as
-     *  `status` does: ask again once `connect` has. Keep the person's choice with the app's saved things, and go back
-     *  to `default` when it's no longer listed as available.
+    /** The models the person's setup can answer this app with now, asked of no model: { models: [{ id, name, model,
+     *  via: { id, name }, available, reason }], default, reason, help, connect }. `name` says the model with what
+     *  answers it ("Claude Sonnet via Claude Code"); `model` is the model's own short name ("Claude Sonnet") and `via`
+     *  what answers it ("claude-code" / "Claude Code", "codex" / "Codex", "openrouter" / "OpenRouter"), both left out
+     *  by an older Lamp. They come with what answers when a call names no `model` first, then by what else answers,
+     *  each with its most capable model first. Every id is the model through one harness: "engine:claude:opus",
+     *  "openrouter:opus", "engine:codex"; a bare "opus" is Opus through whatever answers by default. `default` is the
+     *  id that answers when a call names no `model`; the ids are what `ask` and `act` take as `model`, and one that
+     *  can't answer when it's sent is answered as no choice, never refused. With none to offer, `models` is empty and
+     *  `reason` says why; on a page shared on lamp.dev that hasn't reached this computer yet it asks nothing and
+     *  answers `connect: true`, as `status` does: ask again once `connect` has. Keep the person's choice with the
+     *  app's saved things, and go back to `default` when it's no longer listed as available.
      *
      *     LampAI.models().then(function (m) {
      *       var usable = m.models.filter(function (x) { return x.available; });
+     *       var harnesses = usable.map(function (x) { return x.via ? x.via.name : ''; })
+     *         .filter(function (v, i, all) { return all.indexOf(v) === i; });
      *       picker.hidden = usable.length < 2;
-     *       picker.innerHTML = usable.map(function (x) { return '<option value="' + x.id + '">' + x.name + '</option>'; }).join('');
+     *       picker.replaceChildren();
+     *       usable.forEach(function (x) {
+     *         var where = picker, label = x.via ? x.via.name : '';
+     *         if (harnesses.length > 1) {
+     *           where = [].filter.call(picker.children, function (g) { return g.label === label; })[0];
+     *           if (!where) { where = document.createElement('optgroup'); where.label = label; picker.appendChild(where); }
+     *         }
+     *         where.appendChild(new Option(x.model || x.name, x.id));
+     *         where.lastChild.title = x.name;
+     *       });
      *       picker.value = m.default;
      *     });
      *     LampAI.ask(question, { model: picker.value });
@@ -893,6 +909,9 @@
             return m && typeof m.id === 'string' && m.id;
           }).map(function (m) {
             var one = { id: m.id, name: typeof m.name === 'string' && m.name ? m.name : m.id, available: m.available === true };
+            // What answers it, as its own fields: left out by a Lamp from before they were sent.
+            if (typeof m.model === 'string' && m.model) one.model = m.model;
+            if (m.via && typeof m.via.id === 'string' && m.via.id && typeof m.via.name === 'string' && m.via.name) one.via = { id: m.via.id, name: m.via.name };
             if (!one.available && typeof m.reason === 'string') one.reason = m.reason;
             return one;
           });
@@ -909,7 +928,8 @@
 
     /** options: data (text from outside the app, for the AI to work on, not obey), images (pictures to look at),
      *  system, json (true asks for JSON and gives back the parsed value: describe its exact shape in the prompt),
-     *  model (an id `LampAI.models()` lists, such as "sonnet", "opus", "haiku", "claude-fable-5-2"). */
+     *  model (an id `LampAI.models()` lists, such as "engine:claude:opus" or "openrouter:sonnet"; a bare "opus" is
+     *  Opus through whatever answers by default). */
     ask: function (prompt, options) { return call(prompt, options); },
 
     /**

package/cli/share.mjs

@@ -15,7 +15,7 @@ import { NOTES_FILE, Problem, stateOf } from "./state.mjs";
 import { ANY_BROWSER, CONTROLLERS, CONTROLLERS_FILE, DEVICE_FILE, lampJS, LIBRARIES } from "./dev.mjs";
 import { LIMITS, FILE_LIMITS, PAGE_LIMITS } from "../site/lib/shared-wishes.js";
 import { ideasOf, makerOf, pageUp, publishLink, removeFile, removeIdea, removeLink, replyIdea, sendFile, siteOrigin } from "./link.mjs";
-import { exportApp, sourceLinkOf } from "./lampapp.mjs";
+import { exportApp, sourceLinkOf, takenLinksOf } from "./lampapp.mjs";
 import { scaled, sizeOf } from "./png.mjs";
 import { ignoredFor } from "./ignore.mjs";
 
@@ -244,6 +244,9 @@ export async function share({ layout, words, picture = null, shape = "fill", sit
   // The link this app came from, when it's a copy of one shared there: its page says so.
   const from = sourceLinkOf(layout.folder, site, earlier?.id);
   if (from) body.from = from;
+  // The copies on the site it took changes from: its page says "with changes from" them. None said keeps what it had.
+  const taken = takenLinksOf(layout.folder, site, earlier?.id);
+  if (taken.length) body.with = taken;
   // A file an earlier share sent stays on the record until it's taken away, so a retry after a failed removal tries again.
   // A link that's a Lamp's (`fromLamp`, the app in its own folder) stays so in every write, a share that fails partway too.
   let link = { site, ...(await publishLink({ site, body, earlier, account: accountFor(site)?.key })), ...words, shape, ...(earlier?.file ? { file: true } : {}),

package/cli/skill/SKILL.md

@@ -224,7 +224,8 @@ Only when the person asks about copies or to bring something of one in:
 - `{{lamp}} compare <link>` fetches that copy into lamp's own place for this folder and says what differs from this
   app: files only in theirs, only in yours, and changed. It answers where the copy is: read it from there.
 - `{{lamp}} take <link> "the stadium"` compares, then says how to bring in what the person asked for (leave the words
-  out only when they want everything new), and credits the copy in this app's credits.json for its next share. Bring
+  out only when they want everything new), and credits the copy in this app's credits.json, so the next share's page
+  says "with changes from" that copy and its maker hears of it. Bring
   in only that, written into this app's own files and fitted to it, never their whole app over this one; then look.
   When it's in, tell the person in a sentence what you took from whose copy. A copy shared on lamp.dev was shared for
   anyone to take from, so sharing it on never asks about its license; third-party work the copy itself credits still

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lampdotdev/lamp",
-  "version": "0.36.2-nightly.31",
+  "version": "0.36.2-nightly.35",
   "description": "Runs a web app or game from its folder and puts each saved change into the open page.",
   "type": "module",
   "bin": {

package/site/lib/shared-wishes.js

@@ -29,6 +29,8 @@ export const LIMITS = {
   releases: 30,
   releaseLines: 5,
   releaseLine: 120,
+  /** The other people's copies on the site the app took changes from (`with`), by their ids. */
+  with: 20,
   picture: 1_500_000,
   icon: 300_000,
   /** Pixels on a side, for both pictures. */
@@ -137,11 +139,12 @@ function release(value) {
 }
 
 /** What a share sends, checked. Null when anything is off. `releases` is undefined when the share didn't say (a Lamp
- *  from before them), so a change keeps the ones the link has; `from` too, the id of the link the app is a copy of. */
+ *  from before them), so a change keeps the ones the link has; `from` too, the id of the link the app is a copy of, and
+ *  `with`, the ids of the links whose copies it took changes from (`lamp take`, Lamp's `shared_copy`). */
 const GITHUB_REPO = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/(?!\.\.?$)[A-Za-z0-9._-]{1,100}$/;
 export function readShare(body) {
   if (!body || typeof body !== "object" || Array.isArray(body)) return null;
-  const known = ["name", "by", "line", "words", "ideas", "asks", "shape", "releases", "picture", "icon", "github", "from"];
+  const known = ["name", "by", "line", "words", "ideas", "asks", "shape", "releases", "picture", "icon", "github", "from", "with"];
   if (Object.keys(body).some((key) => !known.includes(key))) return null;
   const name = tidy(body.name, LIMITS.name);
   const words = tidy(body.words, LIMITS.words, { lines: true });
@@ -160,9 +163,10 @@ export function readShare(body) {
   // The app's public repository on GitHub, as "owner/name", which the page links to: nothing else is taken.
   const github = body.github == null || body.github === "" ? null : GITHUB_REPO.test(body.github) ? body.github : undefined;
   const from = body.from == null ? undefined : isID(body.from) ? body.from : null;
-  if (!name || !words || line == null || by == null || ideas.includes(null) || asks.includes(null) || shape === undefined || releases?.includes(null) || !shot || !icon || github === undefined || from === null) return null;
+  const taken = body.with == null ? undefined : Array.isArray(body.with) && body.with.length <= LIMITS.with && body.with.every(isID) ? [...new Set(body.with)] : null;
+  if (!name || !words || line == null || by == null || ideas.includes(null) || asks.includes(null) || shape === undefined || releases?.includes(null) || !shot || !icon || github === undefined || from === null || taken === null) return null;
   return { name, by, line, words, ideas, asks, shape, releases: releases?.sort((a, b) => b.date.localeCompare(a.date)),
-    picture: shot.bytes ? shot : null, icon: icon.bytes ? icon : null, github, from };
+    picture: shot.bytes ? shot : null, icon: icon.bytes ? icon : null, github, from, with: taken };
 }
 
 /** What anyone may see of a shared wish: never its secret. */
@@ -745,6 +749,33 @@ async function copied(kept, from, copy, origin, { env, fetcher, first }) {
   } catch {}
 }
 
+/**
+ * A link started naming copies it took changes from (`with`): each copy's maker told by email, once (the send key), at
+ * the address that confirmed their account (or the copy's own maker address), as `copied` tells a source's. Never fails
+ * the share.
+ */
+async function tookFrom(kept, ids, link, origin, { env, fetcher }) {
+  const one = async (id) => {
+    try {
+      const copy = await kept.get(id);
+      if (!copy) return;
+      const account = copy.owner ? await kept.account(copy.owner) : null;
+      const maker = account ? null : await kept.maker(id);
+      const to = account?.email ?? (maker?.confirmed ? maker.email : null);
+      if (!to) return;
+      const who = link.owner || link.by || "Someone";
+      await sendMail(env, fetcher, { to: [to], subject: `${who} took changes from your ${copy.name}`,
+        text: `${who} took changes from your ${copy.name} into ${link.name}:\n\n${linkOf(origin, link)}\n` }, `with-${link.id}-${id}`);
+    } catch {}
+  };
+  // All at once, and the share waits for them a few seconds at most: it has to answer well within its function's time,
+  // with the link's secret, whatever the mail service does. A send cut short here is only an email not sent.
+  await Promise.race([Promise.all(ids.map(one)), new Promise((done) => setTimeout(done, NOTIFY_MS))]);
+}
+
+/** The longest a share waits on the emails it sends its copies' makers, well within the function's time. */
+const NOTIFY_MS = 6000;
+
 /** The copies of a link as its page lists them, newest first; one taken down since is let go. */
 export async function copiesOf(kept, id, origin) {
   const found = [];
@@ -834,8 +865,12 @@ export function createShareHandler({ env = process.env, fetcher = fetch, store,
       // The link the app is a copy of, kept only while there's such a link and it isn't this one: a share that doesn't
       // say, or names one that's gone, keeps what the record had.
       const from = share.from && share.from !== wishID && (await kept.get(share.from)) ? share.from : null;
+      // The copies it took changes from, kept only while each is there and isn't this link: a share that doesn't say
+      // keeps what the record had, and one that says none clears it.
+      const taken = share.with && (await kept.getMany(share.with.filter((one) => one !== wishID)))
+        .flatMap((record) => (record ? [record.id] : []));
       const words = { name: share.name, by: share.by, line: share.line, words: share.words, ideas: share.ideas, asks: share.asks, shape: share.shape, github: share.github,
-        ...(share.releases ? { releases: share.releases } : {}), ...(from ? { from } : {}), picture: picture || null, icon: icon || null };
+        ...(share.releases ? { releases: share.releases } : {}), ...(from ? { from } : {}), ...(taken ? { with: taken } : {}), picture: picture || null, icon: icon || null };
       // Its name under the account stays what it was first given, whatever the app is called later.
       const named = earlier?.owner ? { owner: earlier.owner, app: earlier.app }
         : owner ? { owner, app: await claimAppName(kept, owner, words.name, wishID) } : {};
@@ -845,6 +880,7 @@ export function createShareHandler({ env = process.env, fetcher = fetch, store,
         const record = { ...earlier, ...words, ...named, updated: time };
         await kept.replace(record);
         if (record.from) await copied(kept, record.from, record, url.origin, { env, fetcher, first: !!from && earlier?.from !== from });
+        if (taken) await tookFrom(kept, taken.filter((one) => !(earlier?.with ?? []).includes(one)), record, url.origin, { env, fetcher });
         // Kept: the name is the record's now, whatever the cleanup after it does.
         uploaded = [];
         claimed = null;
@@ -860,6 +896,7 @@ export function createShareHandler({ env = process.env, fetcher = fetch, store,
       uploaded = [];
       claimed = null;
       if (from) await copied(kept, from, record, url.origin, { env, fetcher, first: true });
+      if (taken) await tookFrom(kept, taken, record, url.origin, { env, fetcher });
       return reply(201, { id: wishID, url: linkOf(url.origin, record), secret });
     } catch {
       try { await kept.removeImages(uploaded); } catch {}
@@ -1365,6 +1402,14 @@ export async function findWish(id, { env = process.env, fetcher = fetch, store,
       if (source) wish.from = { url: linkOf(origin, source), label: source.owner && source.app ? `${source.owner}/${source.app}` : source.name };
     } catch {}
   }
+  // The copies it took changes from, as each is known now, `with` on its page, in one round trip; one taken down since,
+  // or the source already named as `from`, is left out.
+  if (wish && origin && Array.isArray(record.with) && record.with.length) {
+    try {
+      const records = await kept.getMany(record.with.filter((one) => isID(one) && one !== id && one !== record.from));
+      wish.with = records.filter(Boolean).map((copy) => ({ url: linkOf(origin, copy), label: copy.owner && copy.app ? `${copy.owner}/${copy.app}` : copy.name }));
+    } catch {}
+  }
   // How many copies of it people shared, for the page's "copies" (the list itself is asked for when opened).
   if (wish && origin) { try { wish.copies = await kept.copyCount(id); } catch {} }
   return wish;