@henols/c64-re-tools 2.1.0 → 2.1.2

package/src/host-client/transfer.ts

@@ -2,10 +2,10 @@
 // The host never sees a client path: only bytes and the file's type.
 
 import { createHash } from "node:crypto";
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import { dirname, extname, join, relative, sep } from "node:path";
 
-import { isInside, projectRoot, resolveProject, resolveProjectFile, resolveProjectPath } from "../project.ts";
+import { checkOutputPath, isInside, projectRoot, resolveProject, resolveProjectFile, writeProblem } from "../project.ts";
 import { isRefusal } from "../errors.ts";
 import { MAX_ATTACHMENT_BYTES } from "../protocol/framing.ts";
 import { WireFailure } from "../protocol/messages.ts";
@@ -58,34 +58,49 @@ export function readProjectFile(path: string, options: { root?: string } = {}):
   return { bytes: readFileSync(real), type: extname(path).slice(1).toLowerCase() };
 }
 
+/**
+ * The refusal for a write that the file system refused because of the path
+ * (a folder, a file in place of a folder, no permission): invalid-input with
+ * the path. Undefined for another error, which is no fault of the path.
+ */
+export function writeRefusal(error: unknown, path: string, what?: string): WireFailure | undefined {
+  const message = writeProblem(error, path, what);
+  return message === undefined ? undefined : new WireFailure("invalid-input", message);
+}
+
 /**
  * Writes bytes to a project file on the client side, making its directories
- * and overwriting it. Throws WireFailure(invalid-input) for a path outside the
- * project, also one that leaves it through a symbolic link.
+ * and overwriting it. First the check of checkOutputPath, which a script also
+ * does on its output options before any work. Throws WireFailure(invalid-input)
+ * for a path outside the project, also one that leaves it through a symbolic
+ * link, for a path in the knowledge, and for a path that the file system
+ * refuses: a folder, a file in place of a folder, no permission.
  */
 export function writeProjectFile(path: string, bytes: Uint8Array, options: { root?: string; what?: string } = {}): void {
   const root = options.root ?? currentProject();
   const refuse = () => new WireFailure("invalid-input", `${options.what ?? path}: give a path relative to the project folder that stays inside it, not ${path}.`);
   let file: string;
   try {
-    file = resolveProjectPath(path, root);
-  } catch {
-    throw refuse();
+    file = checkOutputPath(path, "file", { root, ...(options.what === undefined ? {} : { what: options.what }) });
+  } catch (error) {
+    if (isRefusal(error)) throw new WireFailure(error.code, error.message);
+    throw error;
   }
-  // The nearest folder that exists must be inside the project before a folder is made below it.
-  let existing = dirname(file);
-  while (!existsSync(existing)) existing = dirname(existing);
-  if (!isInside(realpathSync(root), realpathSync(existing))) throw refuse();
-  mkdirSync(dirname(file), { recursive: true });
-  if (!isInside(realpathSync(root), realpathSync(dirname(file)))) throw refuse();
-  let link = false;
   try {
-    link = lstatSync(file).isSymbolicLink();
+    mkdirSync(dirname(file), { recursive: true });
+    // Again after the folders are made: another process can change the folders between the check and the write.
+    if (!isInside(realpathSync(root), realpathSync(dirname(file)))) throw refuse();
+    let link = false;
+    try {
+      link = lstatSync(file).isSymbolicLink();
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+    if (link) throw refuse();
+    writeFileSync(file, bytes);
   } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    throw writeRefusal(error, path, options.what) ?? error;
   }
-  if (link) throw refuse();
-  writeFileSync(file, bytes);
 }
 
 /** Directories never staged: version control and the toolkit's own project state. */

package/src/knowledge/expression.ts

@@ -119,7 +119,7 @@ function value(node: Node, resolve: (name: string) => number | undefined): numbe
       return node.value;
     case "name": {
       const found = resolve(node.name);
-      if (found === undefined) throw new Refusal("invalid-input", `"${node.name}" is no symbol of the knowledge and no platform name.`);
+      if (found === undefined) throw new Refusal("invalid-input", `${node.name} is not a symbol of the knowledge or a platform name. Give a number, a symbol that knowledge.ts symbols lists, or a platform name that memory-map.ts at gives.`);
       return found;
     }
     case "unary": {

package/src/knowledge/history.ts

@@ -37,8 +37,8 @@ import {
   type SuppressionRow,
   type SymbolRow,
 } from "./read.ts";
-import { DEFAULT_SPACE, type EvidenceKind, type Origin, type Space } from "./schema.ts";
-import { compareText } from "./text.ts";
+import { DEFAULT_SPACE, type CoverageKind, type EvidenceKind, type Origin, type Space } from "./schema.ts";
+import { compareText, NO_REVISION } from "./text.ts";
 import type { Evidence } from "./write.ts";
 
 export interface Revision {
@@ -49,12 +49,49 @@ export interface Revision {
   description?: string;
   inputHash?: string;
   toolVersion?: string;
+  /** A revert: the revision whose knowledge it restored. */
+  restores?: string;
+  /** A revert of one space: that space. A revert without it restored every space. */
+  restoresSpace?: Space;
   /** What the change rests on. */
   evidence?: Evidence[];
 }
 
+/** A memory row of the program: the bytes from an address. */
+export interface MemoryRow {
+  space: Space;
+  address: number;
+  /** The count of bytes in the row. */
+  bytes: number;
+  origin: Origin;
+  revision: string;
+}
+
+/** The entry of the program, and whether it has a machine state and stages. */
+export interface EntryRow {
+  space: Space;
+  address: number;
+  state: boolean;
+  stages: number;
+  origin: Origin;
+  revision: string;
+}
+
+/** A coverage range of one kind. */
+export interface CoverageRow {
+  space: Space;
+  kind: CoverageKind;
+  start: number;
+  end: number;
+  origin: Origin;
+  revision: string;
+}
+
 /** One knowledge row with its validity: from its first revision until the revision that closed it. */
 export type HistoryEntry =
+  | { entity: "memory"; row: MemoryRow; from: string; to?: string }
+  | { entity: "entry"; row: EntryRow; from: string; to?: string }
+  | { entity: "coverage"; row: CoverageRow; from: string; to?: string }
   | { entity: "symbol"; row: SymbolRow; from: string; to?: string }
   | { entity: "analyzer-name"; row: SymbolRow; from: string; to?: string }
   | { entity: "region"; row: RegionRow; from: string; to?: string }
@@ -79,6 +116,8 @@ function toRevision(row: Raw): Revision {
   if (row.description !== null) revision.description = row.description as string;
   if (row.input_hash !== null) revision.inputHash = row.input_hash as string;
   if (row.tool_version !== null) revision.toolVersion = row.tool_version as string;
+  if (row.restored_revision !== null) revision.restores = row.restored_revision as string;
+  if (row.restored_space !== null && row.restored_space !== undefined) revision.restoresSpace = row.restored_space as Space;
   return revision;
 }
 
@@ -170,8 +209,22 @@ export function revisions(db: DatabaseSync | undefined, options: { limit?: numbe
   return (rows as Raw[]).map((row) => withEvidence(db, toRevision(row)));
 }
 
+/** Revision 0: the knowledge before every revision. It is empty, and no write made it, so it has no time, origin or evidence. */
+export interface InitialRevision {
+  id: typeof NO_REVISION;
+  operation: "none";
+  description: string;
+  createdAt?: undefined;
+  origin?: undefined;
+  inputHash?: undefined;
+  toolVersion?: undefined;
+  restores?: undefined;
+  restoresSpace?: undefined;
+  evidence?: undefined;
+}
+
 export interface RevisionChanges {
-  revision: Revision;
+  revision: Revision | InitialRevision;
   /** Rows this revision made current. */
   added: HistoryEntry[];
   /** Rows this revision closed. */
@@ -181,6 +234,7 @@ export interface RevisionChanges {
 /** One revision and exactly what it changed. */
 export function revision(db: DatabaseSync | undefined, text: string): RevisionChanges {
   const id = resolveRevision(db, text);
+  if (id === NO_REVISION) return { revision: { id: NO_REVISION, operation: "none", description: "The knowledge before every revision. It is empty." }, added: [], closed: [] };
   const raw = db?.prepare("SELECT * FROM revisions WHERE id = ?").get(id) as Raw | undefined;
   if (db === undefined || raw === undefined) throw new Refusal("not-found", `There is no revision ${id}.`);
   const tables = [
@@ -196,9 +250,25 @@ export function revision(db: DatabaseSync | undefined, text: string): RevisionCh
     ["macro", "macros", MACRO_COLUMNS, toMacro],
     ["macro-use", "macro_uses", MACRO_USE_COLUMNS, toMacroUse],
   ] as const;
+  // The program: its memory, its entry and its coverage.
+  const program = [
+    ["memory", "memory", "space, address, length(bytes) / 2 AS bytes, origin, valid_from_revision", (row: Raw): MemoryRow => ({ space: row.space as Space, address: row.address as number, bytes: row.bytes as number, origin: row.origin as Origin, revision: row.valid_from_revision as string })],
+    [
+      "entry",
+      "entries",
+      "space, address, state IS NOT NULL AS has_state, json_array_length(coalesce(stages, '[]')) AS stage_count, origin, valid_from_revision",
+      (row: Raw): EntryRow => ({ space: row.space as Space, address: row.address as number, state: row.has_state === 1, stages: row.stage_count as number, origin: row.origin as Origin, revision: row.valid_from_revision as string }),
+    ],
+    [
+      "coverage",
+      "coverage",
+      "space, kind, start_address, end_address, origin, valid_from_revision",
+      (row: Raw): CoverageRow => ({ space: row.space as Space, kind: row.kind as CoverageKind, start: row.start_address as number, end: row.end_address as number, origin: row.origin as Origin, revision: row.valid_from_revision as string }),
+    ],
+  ] as const;
   const added: HistoryEntry[] = [];
   const closed: HistoryEntry[] = [];
-  for (const [entity, table, columns, map] of tables) {
+  for (const [entity, table, columns, map] of [...tables, ...program]) {
     for (const row of db.prepare(`SELECT ${columns}, valid_to_revision FROM ${table} WHERE valid_from_revision = ?`).all(id) as Raw[]) {
       added.push(entry(entity, map(row), row));
     }

package/src/knowledge/import.ts

@@ -77,7 +77,18 @@ export type ImportConflict =
       current: { address: number; name: string; kind: SymbolKind; origin: Origin };
       finding: { name: string; kind: SymbolKind };
     }
-  | { category: "region"; start: number; end: number; current: { type: RegionType; origin: Origin }; finding: { type: RegionType } };
+  | { category: "region"; start: number; end: number; current: { type: RegionType; origin: Origin }; finding: { type: RegionType } }
+  | {
+      /** A data finding over code that a run executed or that the user or the LLM named: the finding is not imported. */
+      category: "code-evidence";
+      start: number;
+      end: number;
+      finding: { type: RegionType };
+      /** The first executed instruction start in the range. */
+      executed?: number;
+      /** The first code name (label or routine) of the user or the LLM in the range. */
+      symbol?: { address: number; name: string; kind: SymbolKind; origin: Origin };
+    };
 
 export interface ImportCounts {
   added: number;
@@ -252,16 +263,53 @@ const YIELDS_TO_HEURISTIC = new Set<Origin>(["dxa", "ghidra"]);
 /** Analyzers whose data gives way to a code finding over an executed instruction start. */
 const YIELDS_TO_EXECUTED_CODE = new Set<Origin>(["dxa", "ghidra"]);
 
+/** The first address in the range that is an executed instruction start, or undefined. */
+function firstExecuted(findings: NormalizedFindings, start: number, end: number): number | undefined {
+  if (findings.executed === undefined) return undefined;
+  for (let address = start; address <= end; address++) if (findings.executed(address)) return address;
+  return undefined;
+}
+
 /** True when an address in the range is an executed instruction start. */
 function holdsExecuted(findings: NormalizedFindings, start: number, end: number): boolean {
-  if (findings.executed === undefined) return false;
-  for (let address = start; address <= end; address++) if (findings.executed(address)) return true;
-  return false;
+  return firstExecuted(findings, start, end) !== undefined;
 }
 
-function importRegions(db: DatabaseSync, change: Change, findings: NormalizedFindings, coverage: AddressRange[], result: ImportResult): void {
-  const { analyzer } = findings;
-  const space = findings.space ?? DEFAULT_SPACE;
+/**
+ * The data findings of DXA or Ghidra that code evidence contradicts: an
+ * executed instruction start, or a code name (label or routine) of the user or
+ * the LLM, in the range. Evidence wins over an analyzer guess: such a finding
+ * is not imported, and the analyzer's own code there stays.
+ */
+function contradictedData(db: DatabaseSync, findings: NormalizedFindings, space: Space): Array<ImportConflict & { category: "code-evidence" }> {
+  if (!YIELDS_TO_EXECUTED_CODE.has(findings.analyzer)) return [];
+  const names = db.prepare(`SELECT ${SYMBOL_COLUMNS} FROM current_symbols WHERE space = ? AND origin IN ('user', 'llm') AND kind IN ('label', 'routine') AND address BETWEEN ? AND ? ORDER BY address LIMIT 1`);
+  const found: Array<ImportConflict & { category: "code-evidence" }> = [];
+  for (const region of findings.regions) {
+    if (isCode(region.type) || region.type === "dual-use") continue;
+    const executed = firstExecuted(findings, region.start, region.end);
+    const raw = names.get(space, region.start, region.end) as Record<string, unknown> | undefined;
+    if (executed === undefined && raw === undefined) continue;
+    const symbol = raw === undefined ? undefined : toSymbol(raw);
+    found.push({
+      category: "code-evidence",
+      start: region.start,
+      end: region.end,
+      finding: { type: region.type },
+      ...(executed === undefined ? {} : { executed }),
+      ...(symbol === undefined ? {} : { symbol: { address: symbol.address, name: symbol.name, kind: symbol.kind, origin: symbol.origin } }),
+    });
+  }
+  return found;
+}
+
+function importRegions(db: DatabaseSync, change: Change, given: NormalizedFindings, coverage: AddressRange[], result: ImportResult): void {
+  const { analyzer } = given;
+  const space = given.space ?? DEFAULT_SPACE;
+  // Data findings over code evidence are conflicts, not facts.
+  const contradicted = contradictedData(db, given, space);
+  result.conflicts.push(...contradicted);
+  const findings = { ...given, regions: given.regions.filter((region) => !contradicted.some((item) => item.start === region.start && item.end === region.end)) };
   if (analyzer === "heuristic") {
     // An idiom is specific evidence about its bytes: the DXA or Ghidra region there gives way, its parts outside stay.
     for (const region of findings.regions) {
@@ -333,6 +381,14 @@ function importRegions(db: DatabaseSync, change: Change, findings: NormalizedFin
       if (suppressed.length > 0) result.regions.suppressed++;
       for (const piece of subtract(region, [...protectedRows, ...suppressed])) desired.set(`${piece.start}-${piece.end}`, { ...piece, type: region.type });
     }
+    // Under a contradicted data finding, the analyzer's own regions stay: they join the findings of the same type next to them.
+    for (const row of own) {
+      for (const item of contradicted) {
+        const inside = { start: Math.max(row.start, item.start, range.start), end: Math.min(row.end, item.end, range.end) };
+        if (inside.start > inside.end) continue;
+        for (const piece of subtract(inside, [...protectedRows, ...suppressionsOverlapping(db, "region", inside.start, inside.end, space)])) keepPiece(desired, { ...piece, type: row.type });
+      }
+    }
     const retiredRanges = new Set<string>();
     for (const row of own) {
       const inside = { start: Math.max(row.start, range.start), end: Math.min(row.end, range.end) };
@@ -357,6 +413,22 @@ function importRegions(db: DatabaseSync, change: Change, findings: NormalizedFin
   }
 }
 
+/** Puts a kept piece into the desired regions, joined with the pieces of the same type that touch or overlap it. */
+function keepPiece(desired: Map<string, { start: number; end: number; type: RegionType }>, piece: { start: number; end: number; type: RegionType }): void {
+  let joined = { ...piece };
+  for (let found = true; found; ) {
+    found = false;
+    for (const [key, other] of desired) {
+      if (other.type !== joined.type || other.end + 1 < joined.start || joined.end + 1 < other.start) continue;
+      desired.delete(key);
+      joined = { start: Math.min(joined.start, other.start), end: Math.max(joined.end, other.end), type: joined.type };
+      found = true;
+      break;
+    }
+  }
+  desired.set(`${joined.start}-${joined.end}`, joined);
+}
+
 function importReferences(db: DatabaseSync, change: Change, findings: NormalizedFindings, coverage: AddressRange[], result: ImportResult): void {
   const { analyzer } = findings;
   const space = findings.space ?? DEFAULT_SPACE;

package/src/knowledge/names.ts

@@ -20,7 +20,8 @@ export function addressOfName(db: DatabaseSync | undefined, name: string, space:
   if (addresses.length === 1) return addresses[0]!;
   const where = space === DEFAULT_SPACE ? "" : ` in ${space}`;
   if (addresses.length > 1) throw new Refusal("invalid-input", `the analyzers give ${name} to ${rows.map((row) => `${formatC64Address(row.address)} (${row.origin})`).join(" and ")}${where}. Give the address`);
-  throw new Refusal("not-found", `no symbol or analyzer name${where} is ${name}`);
+  const option = space === DEFAULT_SPACE ? "" : ` --space ${space}`;
+  throw new Refusal("not-found", `${name} is not a name in the knowledge${where}. Give a $ address, or a name that knowledge.ts symbols${option} lists, with or without --analyzer.`);
 }
 
 /** Every name of a space with its address: the symbols, and each analyzer name that addressOfName accepts. With kinds, only names of those kinds. */

package/src/knowledge/program.ts

@@ -10,6 +10,7 @@ import { Refusal } from "../errors.ts";
 import { type AddressRange, COVERAGE, formatC64Address } from "../c64.ts";
 
 import { COVERAGE_KINDS, DEFAULT_SPACE, MEMORY_ROW, type CoverageKind, type Space } from "./schema.ts";
+import { coverageRuns } from "./read.ts";
 import { checkSpace, write, type Evidence, type WriteContext } from "./write.ts";
 
 /** The 64 KiB of one space: offset n is address n. */
@@ -147,22 +148,6 @@ function currentCoverage(db: DatabaseSync, space: Space): Map<CoverageKind, Uint
   return maps;
 }
 
-/** One import of a coverage map: its project path, its SHA-256, the space it went into and the revision. */
-export interface CoverageRun {
-  name: string;
-  sha256: string;
-  space: Space;
-  revision: string;
-}
-
-/** The imports of coverage maps, by name and then oldest first: the last import of a name is the latest. */
-export function coverageRuns(db: DatabaseSync | undefined): CoverageRun[] {
-  if (db === undefined) return [];
-  return db
-    .prepare(`SELECT DISTINCT e.ref AS name, e.sha256 AS sha256, coalesce(e.space, '${DEFAULT_SPACE}') AS space, e.revision AS revision FROM evidence e JOIN revisions r ON r.id = e.revision WHERE r.operation = 'coverage' AND e.kind = 'coverage' ORDER BY e.ref, e.revision`)
-    .all() as unknown as CoverageRun[];
-}
-
 /**
  * Joins coverage maps into the coverage of a space: adds the ranges of
  * the flags that no imported run set before, and as wx the addresses that one
@@ -239,13 +224,42 @@ export function requireProgram(db: DatabaseSync | undefined, space: Space = DEFA
   throw new Refusal("not-found", `The knowledge has no program${where}. Put it in with knowledge.ts image <image.json|prg>${option} of the c64-knowledge skill.`);
 }
 
-/** The bytes for an analyzer: a PRG for one segment without an entry state, else the 64 KiB. */
+/** The pages of an entry state: $0000-$03ff as the capture wrote them, 256 bytes as hex for each page. */
+const STATE_PAGES = ["$0000", "$0100", "$0200", "$0300"] as const;
+
+/**
+ * The memory that the program has at its entry: the segments, and below them
+ * $0002-$03ff of the entry state (the zero page, the stack and the system
+ * pages hold code and data that the loader left). $0000 and $0001 are the
+ * CPU port, not memory. A segment byte wins over a state byte.
+ */
+export function entryMemory(image: ProgramImage): Uint8Array {
+  const memory = new Uint8Array(image.memory);
+  const pages = image.state?.pages;
+  if (typeof pages !== "object" || pages === null) return memory;
+  const inSegment = (address: number) => image.segments.some((segment) => address >= segment.start && address <= segment.end);
+  STATE_PAGES.forEach((page, index) => {
+    const hex = (pages as Record<string, unknown>)[page];
+    if (typeof hex !== "string" || !/^(?:[0-9a-fA-F]{2}){1,256}$/.test(hex)) return;
+    Buffer.from(hex, "hex").forEach((byte, offset) => {
+      const address = index * 0x100 + offset;
+      if (address >= 2 && !inSegment(address)) memory[address] = byte;
+    });
+  });
+  return memory;
+}
+
+/**
+ * The bytes for an analyzer: a PRG for one segment without an entry state,
+ * else the 64 KiB with the entry-state pages (entryMemory). DXA, Ghidra and
+ * c64-source get the same bytes.
+ */
 export function analyzedBytes(image: ProgramImage): { bytes: Buffer; kind: "prg" | "flat64k" } {
   if (image.segments.length === 1 && image.state === undefined) {
     const [segment] = image.segments;
     return { bytes: Buffer.concat([Buffer.from([segment!.start & 0xff, segment!.start >> 8]), Buffer.from(image.memory.subarray(segment!.start, segment!.end + 1))]), kind: "prg" };
   }
-  return { bytes: Buffer.from(image.memory), kind: "flat64k" };
+  return { bytes: Buffer.from(entryMemory(image)), kind: "flat64k" };
 }
 
 /**

package/src/knowledge/read.ts

@@ -243,6 +243,52 @@ export function currentRevision(db: DatabaseSync | undefined): string {
   return (db.prepare("SELECT max(id) AS id FROM revisions").get() as { id: string | null }).id ?? "0";
 }
 
+/** One import of a coverage map: its project path, its SHA-256, the space it went into and the revision. */
+export interface CoverageRun {
+  name: string;
+  sha256: string;
+  space: Space;
+  revision: string;
+}
+
+/**
+ * The imports of coverage maps that the knowledge has, by name and then oldest
+ * first: the last import of a name is the latest. A revert gives back the maps
+ * of the revision that it restores, so a map that a revert removed is not known.
+ * A revert of one space gives back only the maps of that space.
+ * With `at`, the maps of the knowledge at that revision.
+ */
+export function coverageRuns(db: DatabaseSync | undefined, at?: string): CoverageRun[] {
+  if (db === undefined || at === NO_REVISION) return [];
+  const rows = db
+    .prepare(
+      `SELECT r.id AS id, r.operation AS operation, r.restored_revision AS restored, r.restored_space AS restoredSpace, e.ref AS name, e.sha256 AS sha256, coalesce(e.space, '${DEFAULT_SPACE}') AS space
+       FROM revisions r LEFT JOIN evidence e ON e.revision = r.id AND e.kind = 'coverage'
+       WHERE (r.operation = 'coverage' AND e.id IS NOT NULL) OR (r.operation = 'revert' AND r.restored_revision IS NOT NULL)
+       ORDER BY r.id, e.id`,
+    )
+    .all() as Array<{ id: string; operation: string; restored: string | null; restoredSpace: Space | null; name: string | null; sha256: string | null; space: Space }>;
+  // The maps after each revision that changed them, oldest first.
+  const after: Array<{ id: string; runs: CoverageRun[] }> = [];
+  let runs: CoverageRun[] = [];
+  for (const row of rows) {
+    if (at !== undefined && row.id > at) break;
+    if (row.operation === "revert") {
+      const restored = row.restored!;
+      let then: CoverageRun[] = [];
+      for (const item of after) if (item.id <= restored) then = item.runs;
+      const only = row.restoredSpace;
+      runs = only === null ? then : [...runs.filter((run) => run.space !== only), ...then.filter((run) => run.space === only)];
+    } else {
+      const run: CoverageRun = { name: row.name!, sha256: row.sha256!, space: row.space, revision: row.id };
+      if (!runs.some((item) => item.name === run.name && item.sha256 === run.sha256 && item.space === run.space && item.revision === run.revision)) runs = [...runs, run];
+    }
+    if (after.at(-1)?.id === row.id) after[after.length - 1]!.runs = runs;
+    else after.push({ id: row.id, runs });
+  }
+  return [...runs].sort((a, b) => (a.name === b.name ? (a.revision < b.revision ? -1 : a.revision > b.revision ? 1 : 0) : a.name < b.name ? -1 : 1));
+}
+
 /** At most this many ids are named when a start of an id fits several revisions. */
 const NAMED_REVISIONS = 5;
 

package/src/knowledge/schema.ts

@@ -113,7 +113,9 @@ function createSchema(db: DatabaseSync): void {
         operation    TEXT NOT NULL,
         input_hash   TEXT,
         tool_version TEXT,
-        description  TEXT
+        description  TEXT,
+        restored_revision TEXT,
+        restored_space TEXT
       );
       CREATE TABLE symbols (
         id                  TEXT PRIMARY KEY,
@@ -316,7 +318,7 @@ function createSchema(db: DatabaseSync): void {
 }
 
 /** The version of the index this build makes. An index with another version is emptied and made again. */
-export const INDEX_VERSION = 6;
+export const INDEX_VERSION = 8;
 
 function indexVersion(db: DatabaseSync): number | undefined {
   const hasMeta = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'meta'").get();

package/src/knowledge/text.ts

@@ -187,6 +187,8 @@ const REVISION_FIELDS: readonly Field[] = [
   field("reason", "description", "text", true),
   field("inputHash", "input_hash", "text", true),
   field("toolVersion", "tool_version", "text", true),
+  field("restores", "restored_revision", "text", true),
+  field("restoresSpace", "restored_space", "text", true),
 ];
 
 /** The SQL name of a table: "references" is a keyword. */