@chloejs/core 0.2.3 → 0.3.0

package/serve/changes.ts

@@ -0,0 +1,61 @@
+// An agent's changes, for the site: what changed in its memory and in its own
+// folder, one change in full, undoing one, and when somebody last looked.
+//
+// A change in a memory shows what that memory held, so it is written to the
+// agent's audit log before it is served, like any other read of a memory, and
+// these routes never take a token.
+import type { Agent } from "#chloe/load/load.ts";
+import { change, changes, markSeen, seenAt, undo, type Change, type Place } from "#chloe/services/historyService.ts";
+import { BadRequest, NotFound } from "./errors.ts";
+import { record } from "./memory.ts";
+
+/** A place as the page names it, or a 400. */
+export function placeOf(value: string | null | undefined): Place | undefined {
+  if (value === null || value === undefined || value === "") return undefined;
+  if (value === "memory" || value === "folder") return value;
+  throw new BadRequest(`in is "memory" or "folder", not ${JSON.stringify(value)}.`);
+}
+
+/**
+ * The agent's changes, newest first, with the ones it made since somebody last
+ * looked marked `new`. `path` narrows it to one file's history.
+ */
+export async function agentChanges(
+  agent: Agent,
+  { place, path, limit }: { place?: Place; path?: string; limit?: number },
+  from: string,
+) {
+  const found = await changes(agent, { place, path, limit });
+  if (found.some((one) => one.in === "memory")) await record(agent, "history", path ?? "/", from);
+  const seen = seenAt(agent.name);
+  const marked = found.map((one) => ({ ...one, new: isNew(agent, one, seen) }));
+  return { seen: seen ?? null, unseen: marked.filter((one) => one.new).length, changes: marked };
+}
+
+function isNew(agent: Agent, one: Change, seen: string | undefined): boolean {
+  return one.by === agent.name && (!seen || one.at > seen);
+}
+
+/** One change with its diff. */
+export async function agentChange(agent: Agent, place: Place, id: string, from: string) {
+  const found = await change(agent, place, id);
+  if (!found) throw new NotFound("There is no such change.");
+  if (place === "memory") await record(agent, "read", `change ${found.id}`, from, { bytes: found.diff.length });
+  return { ...found, new: isNew(agent, found, seenAt(agent.name)) };
+}
+
+/** Puts back what one change changed, and commits that. */
+export async function agentUndo(agent: Agent, place: Place, id: string, from: string) {
+  try {
+    const undone = await undo(agent, place, id);
+    if (place === "memory") await record(agent, "undo", undone.files.join(", "), from, { change: id, commit: undone.id });
+    return undone;
+  } catch (error) {
+    throw new BadRequest(error instanceof Error ? error.message : String(error));
+  }
+}
+
+/** Everything up to now has been looked at. */
+export function agentSeen(agent: Agent) {
+  return { seen: markSeen(agent.name) };
+}

package/serve/files.ts

@@ -5,12 +5,17 @@
 // a browser would be live just as fast with nothing type checking it, so code
 // is edited where `npm run check` runs.
 //
+// The agent's memory is never reached from here, even when it is a folder
+// inside this one: a token may read these routes, and every read of a memory
+// is recorded first, by serve/memory.ts and nothing else.
+//
 // The edge of the folder is confine()'s job, inside the calls below: a path
 // from the page is as untrusted as a path from a model.
-import { existsSync, statSync } from "node:fs";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { join, sep } from "node:path";
 
 import { confine } from "#chloe/core/confine.ts";
-import { agentDir } from "#chloe/core/paths.ts";
+import { agentDir, memoryDir } from "#chloe/core/paths.ts";
 import { listFiles, readFiles, writeFiles } from "#chloe/services/filesService.ts";
 
 export interface Entry {
@@ -26,6 +31,20 @@ const DEPTH = 6;
 /** Made by a program, not by anybody, so it is not part of what an agent is. */
 const JUNK = ["__pycache__", "node_modules"];
 
+/** Whether a path is the agent's memory or inside it, however either is reached. */
+function inMemory(agent: string, path: string): boolean {
+  const memory = memoryDir(agent);
+  if (!memory || !existsSync(memory)) return false;
+  const real = realpathSync(memory);
+  let resolved = path;
+  try {
+    resolved = realpathSync(path);
+  } catch {
+    // Not there yet, or a broken link: compared as written.
+  }
+  return resolved === real || resolved.startsWith(real + sep);
+}
+
 /** Everything in one agent's folder, folders first, as a tree. */
 export async function tree(agent: string, path = "", depth = 0): Promise<Entry[]> {
   const { entries } = await listFiles(agentDir(agent), path || undefined);
@@ -35,6 +54,7 @@ export async function tree(agent: string, path = "", depth = 0): Promise<Entry[]
     const name = dir ? entry.slice(0, -1) : entry;
     if (JUNK.includes(name)) continue;
     const at = path ? `${path}/${name}` : name;
+    if (inMemory(agent, join(agentDir(agent), at))) continue;
     out.push({
       name,
       path: at,
@@ -51,11 +71,12 @@ export const editable = (path: string): boolean => path.endsWith(".md");
 /**
  * One thing in the folder, whichever kind it is. Every path in the tree is an
  * address, so a folder answers with what is in it rather than with an error.
- * Nothing there is `null`, which the route turns into a 404.
+ * Nothing there is `null`, which the route turns into a 404, and so is the
+ * agent's memory.
  */
 export async function open(agent: string, path: string) {
   const resolved = confine(agentDir(agent), path);
-  if (!existsSync(resolved)) return null;
+  if (!existsSync(resolved) || inMemory(agent, resolved)) return null;
   if (statSync(resolved).isDirectory()) {
     return { path, dir: true as const, entries: await tree(agent, path) };
   }
@@ -65,6 +86,7 @@ export async function open(agent: string, path: string) {
 
 export async function save(agent: string, path: string, content: string) {
   if (!editable(path)) throw new Error(`${path} is not markdown.`);
+  if (inMemory(agent, confine(agentDir(agent), path))) throw new Error(`${path} is in the agent's memory.`);
   const written = await writeFiles(agentDir(agent), path, content);
   return { path, bytes: written.bytes };
 }

package/serve/http.ts

@@ -13,6 +13,7 @@ import { db } from "#chloe/core/db.ts";
 import { hasChannel, type Agent, type ChannelRoute, type Job } from "#chloe/load/load.ts";
 import type { Clock } from "#chloe/core/clock.ts";
 import { forget, recall } from "#chloe/model/memory.ts";
+import { agentChange, agentChanges, agentSeen, agentUndo, placeOf } from "./changes.ts";
 import { editable, open, save, tree } from "./files.ts";
 import {
   memoryCommit,
@@ -32,7 +33,7 @@ import { checkPass, makePass } from "./pass.ts";
 import { BadRequest, NotFound } from "./errors.ts";
 import { recentWork } from "./recentWork.ts";
 import { describe } from "#chloe/timer/every.ts";
-import { type Caller, caller, createAccount, from, hasAccount, overHttps, setCookie, signIn } from "./login.ts";
+import { type Caller, caller, covers, createAccount, from, hasAccount, overHttps, renew, setCookie, signIn } from "./login.ts";
 import { makeToken, revokeToken, tokens } from "./tokens.ts";
 import { signedInFrom } from "./alerts.ts";
 import { docsPage, type RouteDoc, sitePage } from "./site.ts";
@@ -148,7 +149,7 @@ export const routes: Route[] = [
     },
   },
 
-  // The ways in. These four are the whole of what is answered without a
+  // The ways in. These five are the whole of what is answered without a
   // session, and each says as little as it can.
   {
     method: "GET",
@@ -183,6 +184,30 @@ export const routes: Route[] = [
       json(response, { ok: true });
     },
   },
+  {
+    method: "GET",
+    path: "/api/check",
+    does: "204 when the account is signed in, 401 when not. For a proxy in front of another site under the same login.",
+    handle: ({ response }) => {
+      response.writeHead(204).end();
+    },
+  },
+  {
+    method: "GET",
+    path: "/api/back",
+    does: "Sends a signed-in browser back to ?to=, an https address under login.domain in chloe.config.ts. Anybody else goes to the sign-in page first.",
+    takes: "?to=https://...",
+    open: true,
+    handle: ({ request, response, url }) => {
+      const to = url.searchParams.get("to") ?? "";
+      if (!covers(to)) return void response.writeHead(302, { location: "/" }).end();
+      if (caller(request)?.kind !== "account") {
+        return void response.writeHead(302, { location: `/login?back=${encodeURIComponent(to)}` }).end();
+      }
+      response.setHeader("set-cookie", setCookie(renew(), overHttps(request)));
+      response.writeHead(302, { location: to }).end();
+    },
+  },
 
   // Reading. A token may do all of this.
   {
@@ -275,12 +300,12 @@ export const routes: Route[] = [
   {
     method: "GET",
     path: "/api/runs/:id",
-    does: "One run in full, with every step it took.",
+    does: "One run in full, with every step it took and the commits it made.",
     token: true,
     handle: ({ response, params }) => {
-      const row = db.prepare("select * from runs where id = ?").get(params.id) as { trace: string } | undefined;
+      const row = db.prepare("select * from runs where id = ?").get(params.id) as { trace: string; commits: string | null } | undefined;
       if (!row) throw new NotFound("No run with that id.");
-      json(response, { ...row, trace: JSON.parse(row.trace) });
+      json(response, { ...row, trace: JSON.parse(row.trace), commits: row.commits ? JSON.parse(row.commits) : [] });
     },
   },
   {
@@ -543,6 +568,53 @@ export const routes: Route[] = [
     handle: async ({ request, response, context, params }) =>
       json(response, await memoryPull(context.agent(params.name), from(request))),
   },
+
+  // What an agent changed: the commits in its memory and in its own folder.
+  // A memory's are recorded like any read of it, so none of these takes a token.
+  {
+    method: "GET",
+    path: "/api/agents/:name/changes",
+    does: "Commits to that agent's memory and own folder, newest first, the ones it made since somebody last looked marked new. Takes ?in=memory|folder, ?path= for one file's history, and ?limit=, at most 200.",
+    handle: async ({ request, response, context, params, url }) =>
+      json(
+        response,
+        await agentChanges(
+          context.agent(params.name),
+          {
+            place: placeOf(url.searchParams.get("in")),
+            path: url.searchParams.get("path") || undefined,
+            limit: Math.min(Number(url.searchParams.get("limit") ?? 50) || 50, 200),
+          },
+          from(request),
+        ),
+      ),
+  },
+  {
+    method: "GET",
+    path: "/api/agents/:name/changes/:id",
+    does: "One commit and its diff, cut to that agent's part of the repository. Takes ?in=memory|folder.",
+    handle: async ({ request, response, context, params, url }) => {
+      const place = placeOf(url.searchParams.get("in"));
+      if (!place) return json(response, { error: "Say which: ?in=memory or ?in=folder." }, 400);
+      json(response, await agentChange(context.agent(params.name), place, params.id, from(request)));
+    },
+  },
+  {
+    method: "POST",
+    path: "/api/agents/:name/changes/seen",
+    does: "Everything that agent has changed up to now has been looked at.",
+    handle: ({ response, context, params }) => json(response, agentSeen(context.agent(params.name))),
+  },
+  {
+    method: "POST",
+    path: "/api/agents/:name/changes/:id/undo",
+    does: "Put every file one commit changed back how it was, and commit that. Refused when a file has changed since.",
+    takes: '{"in": "memory"}',
+    handle: async ({ request, response, context, params }) => {
+      const { in: place } = await body(request, z.object({ in: z.enum(["memory", "folder"]) }));
+      json(response, await agentUndo(context.agent(params.name), place, params.id, from(request)));
+    },
+  },
 ];
 
 /** Signing in, and making the account the first time. One body, two doors. */

package/serve/login.ts

@@ -145,10 +145,42 @@ function holds(value: string, held: Account): boolean {
   }
 }
 
-/** The Set-Cookie for a session, or for ending one when the value is empty. */
-export function setCookie(value: string, secure: boolean): string {
+/** The name the login covers along with every site under it, from chloe.config.ts. */
+let domain: string | undefined;
+
+export function shareLogin(name: string | undefined): void {
+  const clean = name?.trim().replace(/^\./, "").toLowerCase();
+  if (clean && !/^[a-z0-9-]+(\.[a-z0-9-]+)+$/.test(clean)) throw new Error(`login.domain "${name}" is not a name like example.com.`);
+  domain = clean || undefined;
+}
+
+/**
+ * Whether an address is one this login covers, so it is safe to send somebody
+ * back there after they sign in. Anything else would let a link send them off
+ * to a stranger's page straight from this one.
+ */
+export function covers(address: string): boolean {
+  if (!domain) return false;
+  try {
+    const url = new URL(address);
+    return url.protocol === "https:" && (url.hostname === domain || url.hostname.endsWith(`.${domain}`));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The Set-Cookie headers for a session, or for ending one when the value is
+ * empty. With a domain set, ending one also ends the cookie made before there
+ * was one, which only this site's own name carried.
+ */
+export function setCookie(value: string, secure: boolean): string[] {
   const rest = `Path=/; HttpOnly; SameSite=Lax${secure ? "; Secure" : ""}`;
-  return value ? `${COOKIE}=${value}; Max-Age=${LASTS}; ${rest}` : `${COOKIE}=; Max-Age=0; ${rest}`;
+  const shared = domain ? `; Domain=${domain}` : "";
+  if (value) return [`${COOKIE}=${value}; Max-Age=${LASTS}; ${rest}${shared}`];
+  const ended = [`${COOKIE}=; Max-Age=0; ${rest}${shared}`];
+  if (domain) ended.push(`${COOKIE}=; Max-Age=0; ${rest}`);
+  return ended;
 }
 
 /**
@@ -162,6 +194,17 @@ export function ownCookie(): string {
   return `${COOKIE}=${sign(held)}`;
 }
 
+/**
+ * A fresh session for somebody already signed in. Sending them back to another
+ * site gives them one, because a session made before login.domain was set only
+ * reached this site, and the other one would send them straight back here.
+ */
+export function renew(): string {
+  const held = read();
+  if (!held) throw new Error("There is no account yet.");
+  return sign(held);
+}
+
 /**
  * Something signed with the account's secret, for a purpose other than a
  * session. The purpose is part of what is signed, so a value made for one

package/serve/memory.ts

@@ -3,8 +3,8 @@
 // Not to be confused with model/memory.ts, which is the last few messages of a
 // conversation. This is a folder: the one an agent reads and writes between
 // runs. Every agent has one, and unless its definition says otherwise it is
-// that agent's own folder under the state directory. An agent that shares a
-// folder with a person, like one that keeps somebody's notes, says where.
+// memory/ inside that agent's own folder. An agent that shares a folder with a
+// person, like one that keeps somebody's notes, says where.
 //
 // Every file served is written down first, and that is the point rather than a
 // detail. Reading these files from a shell is not recorded, because a shell on
@@ -15,13 +15,14 @@
 // refused instead.
 import { execFile } from "node:child_process";
 import { appendFile, mkdir, readFile, rename as move, rm, stat } from "node:fs/promises";
-import { existsSync, realpathSync, statSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { dirname, extname } from "node:path";
 import { promisify } from "node:util";
 
 import { confine, unreachable } from "#chloe/core/confine.ts";
 import type { Agent } from "#chloe/load/load.ts";
 import { listFiles, readFiles, writeFiles } from "#chloe/services/filesService.ts";
+import { commitPaths, memoryRepo } from "#chloe/services/historyService.ts";
 import { STATE } from "#chloe/core/paths.ts";
 import { BadRequest } from "./errors.ts";
 import { noteHead } from "./page.ts";
@@ -50,9 +51,9 @@ export function memoryLabel(agent: Agent): string {
 }
 
 /**
- * Beside the state folder rather than inside the memory it records. For most
- * agents the memory IS their state folder, and a log inside the folder it logs
- * would show up in its own tree and change it every time it was read.
+ * In the state folder rather than inside the memory it records: a log inside
+ * the folder it logs would show up in its own tree, change it every time it
+ * was read, and go wherever the memory is pushed.
  */
 function logFor(agent: Agent): string {
   return `${STATE}/memory-audit/${agent.name}.jsonl`;
@@ -68,7 +69,7 @@ function folder(agent: Agent): string {
  */
 export async function record(
   agent: Agent,
-  what: "read" | "write" | "list" | "serve" | "rename" | "delete" | "commit" | "push" | "pull",
+  what: "read" | "write" | "list" | "serve" | "rename" | "delete" | "commit" | "push" | "pull" | "history" | "undo",
   path: string,
   from: string,
   extra: Record<string, unknown> = {},
@@ -221,6 +222,16 @@ export async function memorySave(agent: Agent, path: string, content: string, fr
   return { path, bytes: written.bytes };
 }
 
+/**
+ * A memory committed at the end of each run gets what is done to it from the
+ * site committed at once, under this box's own git name, so the next run's
+ * commit does not take it in under the agent's.
+ */
+async function committedNow(agent: Agent, paths: string[], message: string): Promise<void> {
+  if (agent.memory.commit !== "each run" || !(await isRepo(agent))) return;
+  await commitPaths(folder(agent), paths, { message });
+}
+
 /** Moves a file or a folder. Both ends have to be inside, and the new one must not exist. */
 export async function memoryRename(agent: Agent, from: string, to: string, who: string) {
   const here = inside(agent, from, who);
@@ -230,6 +241,7 @@ export async function memoryRename(agent: Agent, from: string, to: string, who:
   await mkdir(dirname(there), { recursive: true });
   await move(here, there);
   await record(agent, "rename", from, who, { to });
+  await committedNow(agent, [here, there], `memory: ${from} moved to ${to} from the site`);
   return { from, to };
 }
 
@@ -244,6 +256,7 @@ export async function memoryDelete(agent: Agent, path: string, who: string) {
   }
   await rm(here, { recursive: true });
   await record(agent, "delete", path, who);
+  await committedNow(agent, [here], `memory: ${path} deleted from the site`);
   return { deleted: path };
 }
 
@@ -264,11 +277,17 @@ export async function memoryLog(agent: Agent, limit = 200): Promise<unknown[]> {
     });
 }
 
-// Source control, when the memory is a repo. Enough to mirror the panel an
-// editor puts beside its file tree: what changed, commit it, push, pull, and the
-// recent history. Every call is `git` with an argument array and never a shell
-// string, and nothing here takes a path from the browser: a commit is the whole
-// tree, which is the only shape of commit this offers.
+// Source control on the memory. Enough to mirror the panel an editor puts
+// beside its file tree: what changed, commit it, push, pull, and the recent
+// history. Every call is `git` with an argument array and never a shell string,
+// and nothing here takes a path from the browser: a commit is this memory's
+// whole folder, which is the only shape of commit this offers.
+//
+// One repository holds every agent's memory, a folder each, so what is listed
+// and what is committed is scoped to this memory's folder with `-- .` and cwd
+// set to it. Without that, cc's panel would show tempo's changes and one click
+// would commit them under a message written about something else. Push and pull
+// move the whole repository, because a branch is not per folder.
 
 async function inRepo(agent: Agent, ...args: string[]): Promise<string> {
   const { stdout } = await git("git", args, { cwd: folder(agent), maxBuffer: 8 << 20, timeout: 60_000 });
@@ -276,33 +295,23 @@ async function inRepo(agent: Agent, ...args: string[]): Promise<string> {
 }
 
 /**
- * Whether this memory is itself a git repository: its folder is the top of one.
- *
- * Being inside one is not enough, and that difference is the whole of this
- * function. An agent's memory defaults to its folder under the state
- * directory, and that is usually inside the repo the agents are written in.
- * Asked from there, git walks up and answers for that repo: its branch, its
- * changes, and a "commit all" that stages every file in it from wherever it is
- * run. So a memory panel would show somebody's unrelated work in progress as
- * the memory's own changes, one click would commit it under a message written
- * about something else, and push would send it off the box.
+ * Whether this memory has a history to show: its folder is in a repository that
+ * is not the one the agents themselves are written in. That last part is the
+ * whole of this function. Being inside any repository is not enough: a memory
+ * somebody put inside their source would answer for that repository, and the
+ * panel would show their work in progress as the memory's own changes, commit
+ * it under a message written about something else, and push it off the box.
  */
 async function isRepo(agent: Agent): Promise<boolean> {
-  if (!existsSync(folder(agent))) return false;
-  try {
-    const top = (await inRepo(agent, "rev-parse", "--show-toplevel")).trim();
-    return realpathSync(top) === realpathSync(folder(agent));
-  } catch {
-    return false;
-  }
+  return (await memoryRepo(agent)) !== undefined;
 }
 
 export async function memoryGit(agent: Agent) {
   if (!(await isRepo(agent))) return { repo: false as const };
   const [porcelain, branch, history] = await Promise.all([
-    inRepo(agent, "status", "--porcelain=v1"),
+    inRepo(agent, "status", "--porcelain=v1", "--", "."),
     inRepo(agent, "rev-parse", "--abbrev-ref", "HEAD").catch(() => "HEAD\n"),
-    inRepo(agent, "log", "-20", "--date=short", "--format=%h%x00%ad%x00%an%x00%s").catch(() => ""),
+    inRepo(agent, "log", "-20", "--date=short", "--format=%h%x00%ad%x00%an%x00%s", "--", ".").catch(() => ""),
   ]);
   const changes = porcelain
     .split("\n")
@@ -337,10 +346,10 @@ export async function memoryCommit(agent: Agent, message: string, who: string) {
   const text = message.trim();
   if (!text) throw new BadRequest("Write a commit message first.");
   if (!(await isRepo(agent))) throw new BadRequest("This memory is not a git repository.");
-  await inRepo(agent, "add", "-A");
-  const staged = (await inRepo(agent, "diff", "--cached", "--name-only")).trim();
+  await inRepo(agent, "add", "-A", "--", ".");
+  const staged = (await inRepo(agent, "diff", "--cached", "--name-only", "--", ".")).trim();
   if (!staged) throw new BadRequest("Nothing to commit.");
-  await inRepo(agent, "commit", "-m", text);
+  await inRepo(agent, "commit", "-m", text, "--", ".");
   const sha = (await inRepo(agent, "rev-parse", "--short", "HEAD")).trim();
   await record(agent, "commit", "/", who, { commit: sha, message: text });
   return { commit: sha, files: staged.split("\n").length };

package/serve/site.ts

@@ -173,10 +173,15 @@ function go(form) {
     body: JSON.stringify({ username: form.username.value, password: form.password.value }),
   })
     .then((r) => r.json())
-    .then((a) => { if (a.ok) location = '/'; else document.getElementById('trouble').textContent = a.error; })
+    .then((a) => { if (a.ok) location = back(); else document.getElementById('trouble').textContent = a.error; })
     .catch((e) => { document.getElementById('trouble').textContent = String(e); });
   return false;
 }
+// Where a sign-in started, when another site under the same login sent it here.
+function back() {
+  const to = new URLSearchParams(location.search).get('back');
+  return to ? '/api/back?to=' + encodeURIComponent(to) : '/';
+}
 </script>`,
     false,
   );

package/server.ts

@@ -6,20 +6,25 @@
 // lists them, so adding one is adding it to that list.
 //
 // If this process is not running, nothing fires.
-import { existsSync, readdirSync, watch, type FSWatcher } from "node:fs";
+import { readdirSync, watch, type FSWatcher } from "node:fs";
 
 import { ROOT } from "#chloe/core/paths.ts";
+import { reloadSettings, unclaimed } from "#chloe/core/settings.ts";
 import { closeCutOff, trim } from "#chloe/core/db.ts";
 import { loadAll, type Agent, type Running } from "#chloe/load/load.ts";
 import { via } from "#chloe/model/model.ts";
 import { HOST, PORT, serve } from "#chloe/serve/http.ts";
 import { startClock } from "#chloe/core/clock.ts";
 
-// Credentials a channel reads from the environment can be kept in .env beside
-// the repo, which is not in source control.
-if (existsSync(`${ROOT}/.env`)) process.loadEnvFile(`${ROOT}/.env`);
-
 let agents: Map<string, Agent> = await loadAll();
+
+/** An entry under `agents` in settings that no agent claims is usually one that was renamed. */
+function sayUnclaimed(): void {
+  for (const name of unclaimed([...agents.keys()])) {
+    console.error(`settings: "agents" has an entry for ${name}, and no agent is called that. If it was renamed, rename the entry too.`);
+  }
+}
+sayUnclaimed();
 trim();
 const cutOff = closeCutOff();
 if (cutOff) console.log(`closed ${cutOff} run${cutOff === 1 ? "" : "s"} the last stop cut off`);
@@ -27,10 +32,10 @@ if (cutOff) console.log(`closed ${cutOff} run${cutOff === 1 ? "" : "s"} the last
 const clock = startClock(() => agents);
 
 // Every way in that is not the API: the channels each agent names. A channel
-// keeps running across a reload unless a file in that agent's channels/
-// folder changed, because restarting one drops whatever it was halfway
-// through reading.
-const running = new Map<string, Running>();
+// keeps running across a reload unless the options it was made with changed,
+// wherever they are written, or the settings did, because restarting one drops
+// whatever it was halfway through reading.
+const running = new Map<string, Running & { madeWith?: string }>();
 
 function startChannels(changed: Set<string> = new Set()): void {
   const wanted = new Set<string>();
@@ -38,9 +43,11 @@ function startChannels(changed: Set<string> = new Set()): void {
     for (const one of agent.channels) {
       const key = `${agent.name}/${one.name}`;
       wanted.add(key);
-      if (running.has(key) && !changed.has(agent.name)) continue;
-      running.get(key)?.stop();
-      running.set(key, one.start(() => agents.get(agent.name)));
+      const now = running.get(key);
+      if (now && !changed.has(agent.name) && now.madeWith === one.madeWith) continue;
+      if (now) console.log(`${key}: restarted, ${changed.has(agent.name) ? "the settings" : "its options"} changed`);
+      now?.stop();
+      running.set(key, { ...one.start(() => agents.get(agent.name)), madeWith: one.madeWith });
     }
   }
   for (const [key, one] of running) {
@@ -73,11 +80,11 @@ for (const agent of agents.values()) {
 
 let pending: NodeJS.Timeout | undefined;
 const changedChannels = new Set<string>();
+const SETTINGS = ["settings.json", "settings.local.json"];
+let settingsChanged = false;
 
 function changed(path: string): void {
-  for (const agent of agents.values()) {
-    if (path.startsWith(`${agent.folder}/channels/`)) changedChannels.add(agent.name);
-  }
+  if (SETTINGS.some((file) => path === `${ROOT}/${file}`)) settingsChanged = true;
   clearTimeout(pending);
   pending = setTimeout(reload, 500);
 }
@@ -96,7 +103,14 @@ async function reload(): Promise<void> {
     do {
       again = false;
       try {
+        // A channel reads its token as it starts, so new settings restart them all.
+        if (settingsChanged) {
+          settingsChanged = false;
+          reloadSettings();
+          for (const name of agents.keys()) changedChannels.add(name);
+        }
         agents = await loadAll();
+        sayUnclaimed();
         watchFolders();
         startChannels(changedChannels);
         changedChannels.clear();
@@ -114,7 +128,8 @@ async function reload(): Promise<void> {
 }
 
 /**
- * Reload when chloe.config.ts or anything in an agent's folder changes.
+ * Reload when chloe.config.ts, either settings file, or anything in an
+ * agent's folder changes.
  *
  * Every folder is watched on its own, not recursively. Node's recursive watch
  * on Linux keeps a watch per file, and a file replaced rather than edited in
@@ -125,20 +140,24 @@ async function reload(): Promise<void> {
  * reload halfway through someone writing a file would load a broken one. A
  * reload that throws keeps the agents that were already working, so a typo in
  * one agent does not take the others down.
+ *
+ * An agent's memory is left out even when it is inside the agent's folder:
+ * it changes on every run and is never loaded.
  */
 const watching = new Map<string, FSWatcher>();
 const SKIP = new Set(["node_modules", ".git", "__pycache__"]);
 
-function foldersIn(folder: string): string[] {
+function foldersIn(folder: string, memory: string): string[] {
+  if (folder === memory) return [];
   const found = [folder];
   for (const entry of readdirSync(folder, { withFileTypes: true })) {
-    if (entry.isDirectory() && !SKIP.has(entry.name)) found.push(...foldersIn(`${folder}/${entry.name}`));
+    if (entry.isDirectory() && !SKIP.has(entry.name)) found.push(...foldersIn(`${folder}/${entry.name}`, memory));
   }
   return found;
 }
 
 function watchFolders(): void {
-  const wanted = new Set([ROOT, ...[...agents.values()].flatMap((one) => foldersIn(one.folder))]);
+  const wanted = new Set([ROOT, ...[...agents.values()].flatMap((one) => foldersIn(one.folder, one.memory.folder))]);
   for (const [folder, watcher] of watching) {
     if (!wanted.has(folder)) {
       watcher.close();
@@ -149,7 +168,7 @@ function watchFolders(): void {
     if (watching.has(folder)) continue;
     const top = folder === ROOT;
     const watcher = watch(folder, (_event, file) => {
-      if (file && (!top || file === "chloe.config.ts")) changed(`${folder}/${file}`);
+      if (file && (!top || file === "chloe.config.ts" || SETTINGS.includes(file))) changed(`${folder}/${file}`);
     });
     // A folder that is deleted ends its watch with an error, which would otherwise stop the service.
     watcher.on("error", () => {