@ccmsg/cli 0.9.1 → 0.11.0

package/src/daemon/control.ts

@@ -2,9 +2,10 @@ import { PROTOCOL_VERSION } from "@ccmsg/protocol";
 
 /** One short exchange over an instance's unix socket.
  *
- * The CLI asks one thing at a time, so a `request_id` is a counter and the
- * answer is the next frame: nothing here needs correlation, and the connection
- * lives no longer than the command that opened it. */
+ * The CLI asks one thing at a time, so a `request_id` is a counter — and the
+ * answer is the frame carrying it, not the next one to arrive: an instance
+ * pushes topic frames of its own accord, and one landing mid-exchange would
+ * otherwise be read as the reply. */
 export interface Conn {
   ask(request: Record<string, unknown>): Promise<Record<string, unknown>>;
   /** The next frame the instance sends without having been asked for one: a
@@ -35,8 +36,12 @@ export async function connect(path: string): Promise<Conn | undefined> {
   return {
     ask(request) {
       counter += 1;
-      socket.write(`${JSON.stringify({ request_id: `${counter}`, ...request })}\n`);
-      return replies.next();
+      const id = `${counter}`;
+      // Registered before the write, so a reply that arrives in the same turn
+      // is the one this call settles on.
+      const answer = replies.answer(id);
+      socket.write(`${JSON.stringify({ request_id: id, ...request })}\n`);
+      return answer;
     },
     next() {
       return replies.next();
@@ -55,9 +60,18 @@ export function greetAsUser(conn: Conn): Promise<Record<string, unknown>> {
   return conn.ask({ op: "hello.user", protocol_version: PROTOCOL_VERSION });
 }
 
-/** Reassemble the replies of one exchange, by arrival order. */
+/** Sort what arrives on one connection into the answer somebody is waiting for
+ * and everything else.
+ *
+ * By `request_id` rather than by arrival order, because the two are not the
+ * same stream: an instance pushes topic frames of its own accord (§6), and one
+ * of those landing between a request and its reply would otherwise be read as
+ * the reply. It is not a rare window — greeting an instance that has mesh peers
+ * is enough, since a peer connecting moves a row on `instances`. */
 class Replies {
-  readonly #ready: Record<string, unknown>[] = [];
+  readonly #unasked: Record<string, unknown>[] = [];
+  readonly #answers = new Map<string, (frame: Record<string, unknown>) => void>();
+  readonly #ready = new Map<string, Record<string, unknown>>();
   #waiting: ((frame: Record<string, unknown>) => void) | undefined;
   #buffer = "";
 
@@ -69,8 +83,33 @@ class Replies {
       this.#buffer = this.#buffer.slice(at + 1);
       if (line.trim() === "") continue;
       const frame = JSON.parse(line) as Record<string, unknown>;
+      const id = frame["request_id"];
+      if (typeof id === "string") {
+        const asked = this.#answers.get(id);
+        if (asked !== undefined) {
+          this.#answers.delete(id);
+          asked(frame);
+          continue;
+        }
+        if (this.#answers.size > 0) {
+          // A reply to something still being waited for by somebody who has not
+          // got here yet: held by its id rather than queued as unasked-for.
+          this.#ready.set(id, frame);
+          continue;
+        }
+      } else if (frame["ev"] === undefined && this.#answers.size === 1) {
+        // An answer that named nothing, while exactly one thing is waiting for
+        // one: it is that one. Matching only by id would leave a caller waiting
+        // for ever on a refusal raised before the request could be read, which
+        // is the moment an answer is most needed.
+        for (const [pending, settle] of this.#answers) {
+          this.#answers.delete(pending);
+          settle(frame);
+        }
+        continue;
+      }
       const waiting = this.#waiting;
-      if (waiting === undefined) this.#ready.push(frame);
+      if (waiting === undefined) this.#unasked.push(frame);
       else {
         this.#waiting = undefined;
         waiting(frame);
@@ -78,8 +117,21 @@ class Replies {
     }
   }
 
+  /** The reply to one request, whenever it lands. */
+  answer(id: string): Promise<Record<string, unknown>> {
+    const already = this.#ready.get(id);
+    if (already !== undefined) {
+      this.#ready.delete(id);
+      return Promise.resolve(already);
+    }
+    return new Promise((resolve) => {
+      this.#answers.set(id, resolve);
+    });
+  }
+
+  /** The next frame nobody asked for. */
   next(): Promise<Record<string, unknown>> {
-    const first = this.#ready.shift();
+    const first = this.#unasked.shift();
     if (first !== undefined) return Promise.resolve(first);
     return new Promise((resolve) => {
       this.#waiting = resolve;

package/src/daemon/registry.ts

@@ -1,15 +1,25 @@
-import { existsSync, mkdirSync, watch } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, watch, writeFileSync } from "node:fs";
 import { basename, isAbsolute, join, resolve } from "node:path";
 import type { Endpoint, InstanceId, InstancePingResult } from "@ccmsg/protocol";
-import { DEFAULT_HARNESS, type Harness, HARNESS, isHarness } from "../harness/index.ts";
+import { DEFAULT_HARNESS, type Harness, HARNESS, HARNESSES } from "../harness/index.ts";
 import {
+  applied,
+  type ConfigProblem,
+  CONFIG_FILE,
+  CONFIG_NAME,
+  configOf,
+  DEFAULT_CONFIG,
+  type EndpointRow,
+  ENDPOINTS_FILE,
+  evaluate,
   type InstanceConfig,
-  type InstanceEntry,
-  loadConfig,
-  loadShared,
-  saveShared,
-  settingsFor,
-  type SharedConfig,
+  instanceFileName,
+  type InstanceSetting,
+  type Satisfied,
+  settle,
+  SUPERVISOR_FILE,
+  TYPES_FILE,
+  writeConfigTypes,
 } from "../instance/config.ts";
 import { instanceIdentity } from "../instance/identity.ts";
 import { alive, lockHolder } from "../instance/lock.ts";
@@ -37,25 +47,61 @@ export function configHome(dir: string, harness: Harness = DEFAULT_HARNESS): str
   return path;
 }
 
-/** Which harness a registered config home runs, as the shared file records it.
+/** Which harness a registered config home runs, as its own file says.
  *
- * Read from the same entry the instance itself will read (§8.2), so a command
+ * Read from the same file the instance itself will read (§8.2), so a command
  * that has to know before anything is running — `run`, and the supervisor's
- * own start — reaches the same answer the instance does. A directory the file
- * does not list runs the default, which is what an unregistered `daemon run`
- * is. */
-export function harnessFor(env: Env, dir: string): Harness {
+ * own start — reaches the same answer the instance does. A directory no file
+ * names runs whatever the defaults say, which is what an unregistered
+ * `daemon run` is. */
+export async function harnessFor(env: Env, dir: string): Promise<Harness> {
   const path = isAbsolute(dir) ? dir : resolve(dir);
-  const settings = settingsFor(loadShared(resolvePaths(env).configFile), path);
-  const named = settings["harness"];
-  return isHarness(named) ? named : DEFAULT_HARNESS;
+  const found = (await known(env)).instances.find((one) => one.dir === path);
+  return found?.config.harness ?? DEFAULT_HARNESS;
+}
+
+/** What this host runs: the settings that are applied, read again from the
+ * files when they check out.
+ *
+ * Every command goes through the one path — read, check, apply — so what a
+ * command acts on is what a start would run. A config that does not check out
+ * leaves the applied one standing, which is what keeps a command about one
+ * instance working while another instance's file is being edited. */
+export async function known(env: Env): Promise<Satisfied> {
+  const paths = resolvePaths(env);
+  const read = await evaluate(paths.configDir);
+  return read.satisfied ?? applied(paths.stateRoot) ?? EMPTY_SATISFIED;
+}
+
+const EMPTY_SATISFIED: Satisfied = {
+  endpoints: [],
+  supervisor: { instances: [] },
+  instances: [],
+};
+
+/** Read the files, check them, and write down what holds — the one thing a
+ * start, a reload, an `add` and a `remove` all do. */
+export async function reload(env: Env): Promise<{
+  satisfied: Satisfied;
+  problems: readonly ConfigProblem[];
+}> {
+  const paths = resolvePaths(env);
+  const settled = await settle(paths.configDir, paths.stateRoot);
+  return { satisfied: settled.satisfied, problems: settled.problems };
 }
 
 /** One row of `daemon list`: which config home, and whether anything answers
  * for it right now. */
 export interface InstanceRow {
   readonly id: InstanceId;
+  /** The label this instance is listed under: its own file's `name`, which
+   * defaults to its id. A `daemon run` on a config home nothing states
+   * settings for has none. */
+  readonly name?: string;
   readonly dir: string;
+  /** The address it binds, and the one its peers dial (§7.1). */
+  readonly port?: number;
+  readonly endpoint?: string;
   readonly running: boolean;
   readonly pid?: number;
 }
@@ -63,6 +109,9 @@ export interface InstanceRow {
 /** One row of `daemon status`: the list's row, plus what the instance itself
  * says when there is one to ask. */
 export interface StatusRow extends InstanceRow {
+  /** What was wrong with the files, where the applied settings are older than
+   * what is written. */
+  readonly config_problems?: readonly ConfigProblem[];
   /** What this config home's instance is configured with, after the shared
    * file's defaults and its own entry are merged (§8.2).
    *
@@ -81,18 +130,36 @@ export interface StatusRow extends InstanceRow {
 
 /** Everything one command needs to reach one config home. */
 export interface Target {
+  /** The label this instance is listed under, where it is registered. */
+  readonly name?: string;
+  /** Its id, which is what its file is called. */
+  readonly id?: string;
   readonly dir: string;
   readonly paths: InstancePaths;
 }
 
-export function targetFor(env: Env, dir: string): Target {
-  return { dir, paths: resolvePathsFor(dir, env) };
+export function targetFor(env: Env, dir: string, name?: string, id?: string): Target {
+  return {
+    ...(name === undefined ? {} : { name }),
+    ...(id === undefined ? {} : { id }),
+    dir,
+    paths: resolvePathsFor(dir, env),
+  };
+}
+
+/** The config homes this host starts, in the order the supervisor lists them. */
+export async function registered(env: Env): Promise<Target[]> {
+  return (await known(env)).instances.map((entry) =>
+    targetFor(env, entry.dir, entry.name, entry.id),
+  );
 }
 
-/** The config homes the shared file lists, in the order it lists them. */
-export function registered(env: Env): Target[] {
-  const paths = resolvePaths(env);
-  return loadShared(paths.configFile).instances.map((entry) => targetFor(env, entry.dir));
+/** The instance a command was given, by any of the three things a person has
+ * to hand: the label it is listed under, its id, or the directory itself. */
+export async function targetNamed(env: Env, ref: string): Promise<Target | undefined> {
+  return (await registered(env)).find(
+    (target) => target.name === ref || target.id === ref || target.dir === ref,
+  );
 }
 
 /** The selections the shared file starts with.
@@ -138,55 +205,293 @@ const STARTING_PRESETS = [
   },
 ];
 
-/** Add a config home to the shared file. The settings it will run with are the
- * defaults until somebody edits its entry, so the entry starts empty — save
- * for the harness, which is written down when it is not the default because it
- * is the one setting the directory itself cannot be asked for (§3.8).
+/** What `daemon add` takes: the config home the instance answers for, and the
+ * two settings a person would otherwise open the file to write. */
+export interface AddOptions {
+  readonly harness?: Harness;
+  readonly port?: number;
+}
+
+/** What a config home is called, for a person reading a listing: its own last
+ * segment, without the dot a config home is usually hidden by.
+ *
+ * A label and not an identity — the file and everything the instance issued
+ * are keyed by its id, so this may be changed in the file afterwards. Taken
+ * from the directory because that is the one of the two that already exists;
+ * a directory whose name could not be a label leaves the id as the name, which
+ * is what a name defaults to anyway. */
+export function nameFor(dir: string): string {
+  const name = basename(dir).replace(/^\.+/, "");
+  return CONFIG_NAME.test(name) ? name : "";
+}
+
+/** Which harness a config home runs, as the directory itself says.
+ *
+ * The marker file is the evidence: Claude Code keeps `settings.json` and Codex
+ * keeps `config.toml`, so a directory that holds one of them is that harness's
+ * (§3.8). A directory holding both, or neither, is not answered for — the
+ * first is two answers and the second is none, and guessing either way writes
+ * down a setting the instance will act on for the whole of its life. */
+export function harnessOf(dir: string): Harness {
+  const found = HARNESSES.filter((harness) => existsSync(join(dir, HARNESS[harness].marker)));
+  const only = found[0];
+  if (found.length !== 1 || only === undefined) {
+    throw new CommandError(
+      "invalid_args",
+      found.length === 0
+        ? `${dir} がどの harness の config home か分かりません (${HARNESSES.map((one) => HARNESS[one].marker).join(" / ")} がありません)。--harness で指定してください`
+        : `${dir} は ${found.join(" と ")} の両方の目印を持っています。--harness で指定してください`,
+    );
+  }
+  return only;
+}
+
+/** The port the next instance listens on: one past the highest any registered
+ * instance holds, or the first of the range when there are none.
  *
- * The dump presets above go to `defaults`, and only where the file names none:
- * they are the same for every instance and are examples to edit, so writing
- * them per entry would repeat them and re-adding a config home would bring
- * back what somebody deleted. */
-export function add(env: Env, dir: string, harness: Harness = DEFAULT_HARNESS): InstanceRow {
-  const home = configHome(dir, harness);
-  const file = resolvePaths(env).configFile;
-  const shared = loadShared(file);
-  if (shared.instances.some((entry) => entry.dir === home)) {
-    throw new CommandError("file_exists", `${home} は既に登録されています`);
+ * Counted from what is configured and then confirmed against the kernel,
+ * because the two answer different questions — the first is what this host has
+ * already handed out, and the second is whether anything else on the machine
+ * is on it. A person who wants a particular port says so and gets it or gets
+ * the refusal. */
+export const FIRST_PORT = 8643;
+
+/** How far the search walks before it says so rather than going on. A run of
+ * this many taken ports is a host whose ports are somebody else's business. */
+const PORT_SEARCH = 64;
+
+export async function freePort(taken: readonly number[]): Promise<number> {
+  const first = taken.length === 0 ? FIRST_PORT : Math.max(...taken) + 1;
+  for (let port = first; port < first + PORT_SEARCH; port += 1) {
+    if (taken.includes(port)) continue;
+    if (await bindable(port)) return port;
   }
-  const entry: InstanceEntry = {
-    dir: home,
-    settings: harness === DEFAULT_HARNESS ? {} : { harness },
-  };
-  const defaults =
-    shared.defaults["dump"] === undefined
-      ? { ...shared.defaults, dump: { presets: STARTING_PRESETS } }
-      : shared.defaults;
-  saveShared(file, { defaults, instances: [...shared.instances, entry] });
-  const target = targetFor(env, home);
-  // The id is made here rather than at the first start, so that what `add`
-  // prints is what the instance will answer to and so that a person can write
-  // the id into a peer's config before anything has run (DR-0001 §2.1).
-  instanceIdentity(target.paths.instanceIdFile);
-  return rowFor(target);
-}
-
-/** Take a config home off the list.
+  throw new CommandError(
+    "internal_error",
+    `${String(first)} から ${String(PORT_SEARCH)} 個のポートが全部塞がっています。--port で指定してください`,
+  );
+}
+
+/** Whether this host will give out an address, asked by taking it and letting
+ * it go again. Nothing else answers it: a port is free when the kernel says
+ * so, and every other account of it is out of date the moment it is read. */
+async function bindable(port: number): Promise<boolean> {
+  try {
+    const server = Bun.serve({ hostname: "127.0.0.1", port, fetch: () => new Response("") });
+    await server.stop(true);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Write down one more instance: one file under `instances/`, called by the
+ * name the instance is called.
+ *
+ * A template rather than an empty file, because what the file has to say —
+ * which config home, and how a setting is written at all — is exactly what a
+ * person adding their second instance does not yet know. It states only what
+ * differs from the shared file, which is what makes that file worth having:
+ * everything left out is whatever that file returns.
  *
- * The instance it names is left alone: what this changes is what the supervisor
+ * The shared file is written the first time, with the dump presets in it, and never
+ * again: what a preset names is an interest this instance has no opinion on, so
+ * they are examples in a file to edit rather than a default in the code that
+ * would come back after being deleted. */
+export async function add(env: Env, dir: string, options: AddOptions = {}): Promise<InstanceRow> {
+  const where = isAbsolute(dir) ? dir : resolve(dir);
+  const harness = options.harness ?? harnessOf(where);
+  const home = configHome(where, harness);
+  const paths = resolvePaths(env);
+  const held = await known(env);
+  const taken = held.instances.find((one) => one.dir === home);
+  if (taken !== undefined) {
+    throw new CommandError("file_exists", `${home} は既に ${taken.name} として登録されています`);
+  }
+  // The id the state directory already holds, or a new one written there now:
+  // a config home that was registered before keeps the id everything it issued
+  // is keyed by, and a fresh one gets its id here rather than at its first
+  // start (DR-0001 §2.1).
+  const id = instanceIdentity(targetFor(env, home).paths.instanceIdFile);
+  // Every instance listens, because an instance is an entry of the mesh (§7.1)
+  // and a mesh is reached over the entry: what `--port` settles is which
+  // address, not whether there is one.
+  const port =
+    options.port ??
+    (await freePort(
+      held.instances.flatMap((one) =>
+        one.config.entry === undefined ? [] : [one.config.entry.port],
+      ),
+    ));
+  const name = nameFor(home) || id;
+  writeConfigTypes(paths.configDir);
+  if (!existsSync(paths.configFile)) writeFileSync(paths.configFile, defaultsTemplate());
+  mkdirSync(paths.instancesDir, { recursive: true });
+  writeFileSync(
+    join(paths.instancesDir, instanceFileName(id)),
+    instanceTemplate(name, home, harness, port),
+  );
+  // The loopback address, because that is the one this host is certainly
+  // reached at. A proxy in front of it is a deployment fact nothing here can
+  // see, so an operator who has one edits this row (§8.2).
+  saveEndpoints(paths.configDir, [
+    ...readEndpointRows(paths.configDir).filter((row) => row.id !== id),
+    { id, endpoint: `http://127.0.0.1:${String(port)}/` as EndpointRow["endpoint"] },
+  ]);
+  saveSupervisor(paths.configDir, [
+    ...readSupervised(paths.configDir).filter((one) => one !== id),
+    id,
+  ]);
+  const settled = await reload(env);
+  const written = configOf(settled.satisfied, home);
+  if (written === undefined) {
+    throw new CommandError(
+      "internal_error",
+      `${home} を書きましたが設定が通りませんでした: ${settled.problems
+        .map((one) => `${one.file}: ${one.msg}`)
+        .join("; ")}`,
+    );
+  }
+  return rowOf(env, written);
+}
+
+/** The mesh as the file holds it right now, for a command that is about to
+ * edit it. Read as data rather than through the checks, because a command that
+ * adds a row has to be able to fix a file that does not check out yet. */
+function readEndpointRows(configDir: string): EndpointRow[] {
+  try {
+    const parsed = JSON.parse(readFileSync(join(configDir, ENDPOINTS_FILE), "utf8")) as unknown;
+    return Array.isArray(parsed) ? (parsed as EndpointRow[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+function readSupervised(configDir: string): string[] {
+  try {
+    const parsed = JSON.parse(readFileSync(join(configDir, SUPERVISOR_FILE), "utf8")) as {
+      instances?: unknown;
+    };
+    return Array.isArray(parsed.instances) ? (parsed.instances as string[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+function saveEndpoints(configDir: string, rows: readonly EndpointRow[]): void {
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(join(configDir, ENDPOINTS_FILE), `${JSON.stringify(rows, null, 2)}\n`);
+}
+
+function saveSupervisor(configDir: string, ids: readonly string[]): void {
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(
+    join(configDir, SUPERVISOR_FILE),
+    `${JSON.stringify({ instances: ids }, null, 2)}\n`,
+  );
+}
+
+/** Take one instance's file away.
+ *
+ * The instance it named is left alone: what this changes is what the supervisor
  * starts and what `--all` reaches, and an instance already serving a session is
- * not something a list edit should take away from it. `daemon stop` is how one
+ * not something a file edit should take away from it. `daemon stop` is how one
  * is stopped, and saying so is the point of keeping the two apart. */
-export function remove(env: Env, dir: string): { dir: string; removed: boolean } {
-  const home = isAbsolute(dir) ? dir : resolve(dir);
-  const file = resolvePaths(env).configFile;
-  const shared: SharedConfig = loadShared(file);
-  const kept = shared.instances.filter((entry) => entry.dir !== home);
-  if (kept.length === shared.instances.length) {
-    throw new CommandError("not_found", `${home} は登録されていません`);
-  }
-  saveShared(file, { ...shared, instances: kept });
-  return { dir: home, removed: true };
+export async function remove(
+  env: Env,
+  ref: string,
+): Promise<{ id: string; name: string; dir: string; removed: boolean }> {
+  const paths = resolvePaths(env);
+  const found = (await known(env)).instances.find(
+    (one) => one.id === ref || one.name === ref || one.dir === ref,
+  );
+  if (found === undefined) throw new CommandError("not_found", `${ref} は登録されていません`);
+  saveSupervisor(
+    paths.configDir,
+    readSupervised(paths.configDir).filter((one) => one !== found.id),
+  );
+  saveEndpoints(
+    paths.configDir,
+    readEndpointRows(paths.configDir).filter((row) => row.id !== found.id),
+  );
+  rmSync(join(paths.instancesDir, instanceFileName(found.id)), { force: true });
+  // The state directory stays, its id with it: what the instance issued is
+  // keyed by that id, and re-adding the same config home has to answer to the
+  // same one.
+  await reload(env);
+  return { id: found.id, name: found.name, dir: found.dir, removed: true };
+}
+
+/** The file every instance's settings start from, as it is first written. */
+function defaultsTemplate(): string {
+  return `import type { Defaults } from "./${TYPES_FILE.replace(/\.d\.ts$/, "")}";
+
+/** 全 instance に配る値。\`builtin\` は組み込みの既定値 (凍結済み)、\`config\` は
+ * そのコピーなので、書き換えて返す。ここに書いた値を各 instance が受け取る。 */
+const defaults: Defaults = ({ config }) => {
+  // mesh はここには書かない。誰が居てどこで届くかは endpoints.json が正で、
+  // この関数は読めるが変えられない。
+
+  // dump の名前付き選択。prefix は一族を、\`@name\` は他の選択をその場に広げる。
+  config.dump.presets = [
+${STARTING_PRESETS.map((preset) => presetLiteral(preset)).join("\n")}
+  ];
+
+  return config;
+};
+
+export default defaults;
+`;
+}
+
+/** One starting preset as a person would have typed it.
+ *
+ * Written out rather than stringified, because what this produces is a file
+ * somebody edits: JSON's quoted keys in the middle of a TypeScript file are
+ * the shape of a thing that was generated, and the next preset a person adds
+ * beside it would not look like it. */
+function presetLiteral(preset: (typeof STARTING_PRESETS)[number]): string {
+  const types = preset.opts.types.map((type) => JSON.stringify(type)).join(", ");
+  return [
+    "    {",
+    `      name: ${JSON.stringify(preset.name)},`,
+    `      description: ${JSON.stringify(preset.description)},`,
+    `      opts: { types: [${types}] },`,
+    "    },",
+  ].join("\n");
+}
+
+/** One instance's file, as `add` first writes it: what differs from
+ * the shared file, and nothing else. */
+function instanceTemplate(name: string, dir: string, harness: Harness, port: number): string {
+  const lines = [
+    `  config.name = ${JSON.stringify(name)};`,
+    `  config.dir = ${JSON.stringify(dir)};`,
+    "",
+    "  // reverse proxy の後ろに居るなら、peer と人が届く公開 URL (末尾 /) を書く。",
+    "  // 書かなければ下の待ち受け address がそのまま mesh の一覧に載る。",
+    `  // config.endpoint = "https://ccmsg-${name}.<host>/";`,
+    "",
+  ];
+  if (harness !== DEFAULT_HARNESS) lines.push(`  config.harness = ${JSON.stringify(harness)};`);
+  lines.push(
+    `  config.entry = {`,
+    `    ...(config.entry ?? { host: "127.0.0.1", source_ips: [], trusted_proxies: [] }),`,
+    `    port: ${String(port)},`,
+    `  };`,
+  );
+  return `import type { Instance } from "../${TYPES_FILE.replace(/\.d\.ts$/, "")}";
+
+/** ${name}: この instance だけの設定。\`default\` は ${CONFIG_FILE} が返した値
+ * (凍結済み)、\`config\` はそのコピーなので、差分だけ書き換えて返す。 */
+const instance: Instance = ({ config }) => {
+${lines.join("\n")}
+
+  return config;
+};
+
+export default instance;
+`;
 }
 
 /** What an instance is called, whether or not it is running.
@@ -204,20 +509,43 @@ export function rowFor(target: Target): InstanceRow {
   const running = pid !== undefined && alive(pid);
   return {
     id: idOf(target),
+    ...(target.name === undefined ? {} : { name: target.name }),
     dir: target.dir,
     running,
     ...(running ? { pid } : {}),
   };
 }
 
-export function list(env: Env): InstanceRow[] {
-  return registered(env).map((target) => rowFor(target));
+/** What `daemon list` answers: the instances this host starts, and whether
+ * anything answers for each right now. */
+export async function list(env: Env): Promise<InstanceRow[]> {
+  return (await known(env)).instances.map((one) => rowOf(env, one));
+}
+
+function rowOf(env: Env, one: InstanceSetting): InstanceRow {
+  return {
+    ...rowFor(targetFor(env, one.dir, one.name, one.id)),
+    ...(one.config.entry === undefined ? {} : { port: one.config.entry.port }),
+    ...(one.config.endpoint === undefined ? {} : { endpoint: one.config.endpoint }),
+  };
 }
 
 /** Ask one instance how it is. A config home with nothing behind it answers the
  * list's row and nothing more: not running is a state, not a failure. */
 export async function status(target: Target): Promise<StatusRow> {
-  const row = { ...rowFor(target), config: loadConfig(target.paths.configFile, target.dir) };
+  const read = await evaluate(target.paths.configDir);
+  const satisfied = read.satisfied ?? applied(target.paths.stateRoot) ?? EMPTY_SATISFIED;
+  const own = configOf(satisfied, target.dir);
+  const row = {
+    ...rowFor(target),
+    ...(own?.config.entry === undefined ? {} : { port: own.config.entry.port }),
+    ...(own?.config.endpoint === undefined ? {} : { endpoint: own.config.endpoint }),
+    config: own?.config ?? DEFAULT_CONFIG,
+    // What a person has to be told even though the instance is running: an
+    // edit that did not check out is not applied, and the only sign of it
+    // otherwise is a setting that did not take (§8.3).
+    ...(read.problems.length === 0 ? {} : { config_problems: read.problems }),
+  };
   const conn = await connect(target.paths.socket);
   if (conn === undefined) return row;
   try {