pi-weave 0.3.8 → 0.3.9

package/src/core/repoAction.ts

@@ -1,21 +1,14 @@
-import {
-  assessStaleness,
-  buildRepoIndex,
-  readRepoIndex,
-  summarizeIndex,
-  writeRepoIndex,
-} from "./repoIndex";
+import { ensureRepoIndex, summarizeIndex } from "./repoIndex";
 import { findGitRoot } from "./git";
-import { repoIndexDir } from "./paths";
+import { readSummaries } from "./summaries";
 
 export const WEAVE_REPO_DESCRIPTION =
   "Explore the current git repository through its pi-weave knowledge index (.okf). " +
-  "Actions: status (index freshness vs git state), scan (build/refresh the index), " +
-  "overview (read the indexed structure: languages, packages, modules, entry points). " +
-  "The index is derived and rebuildable; scanning is always safe.";
+  "Action: overview (languages, packages, modules, entry points, and how many files have deep-scan summaries). " +
+  "The index is derived, rebuilt automatically when the repository changes, and never needs a manual scan.";
 
 export interface RepoActionInput {
-  action: "status" | "scan" | "overview";
+  action: "overview";
 }
 
 export interface RepoActionResult {
@@ -23,11 +16,7 @@ export interface RepoActionResult {
   details: Record<string, unknown>;
 }
 
-export async function executeRepoAction(
-  params: RepoActionInput,
-  cwd: string,
-  onProgress?: (text: string) => void | Promise<void>,
-): Promise<RepoActionResult> {
+export async function executeRepoAction(params: RepoActionInput, cwd: string): Promise<RepoActionResult> {
   const root = await findGitRoot(cwd);
   if (!root) {
     return {
@@ -36,49 +25,19 @@ export async function executeRepoAction(
     };
   }
 
-  switch (params.action) {
-    case "status": {
-      const staleness = await assessStaleness(root);
-      const index = staleness.state !== "missing" ? await readRepoIndex(root) : null;
-      const lines = [`Index state: ${staleness.state}`];
-      for (const reason of staleness.reasons) lines.push(`- ${reason}`);
-      if (index) lines.push(`Indexed at: ${index.updated} by ${index.generator}`);
-      return {
-        text: `Repository ${root}\n${lines.join("\n")}`,
-        details: { action: "status", inRepo: true, staleness, indexed: index !== null },
-      };
-    }
-
-    case "scan": {
-      await onProgress?.(`Scanning ${root}…`);
-      const index = await buildRepoIndex(root);
-      if (!index) {
-        return {
-          text: "Cannot build index: the repository has no commits yet.",
-          details: { action: "scan", inRepo: true, scanned: false },
-        };
-      }
-      const dir = await writeRepoIndex(root, index);
-      return {
-        text: `Knowledge index written to ${dir}\n\n${summarizeIndex(index).join("\n")}`,
-        details: { action: "scan", inRepo: true, scanned: true, index },
-      };
-    }
-
-    case "overview": {
-      const index = await readRepoIndex(root);
-      if (!index) {
-        return {
-          text: `No knowledge index at ${repoIndexDir(root)} yet. Use action=scan to build one.`,
-          details: { action: "overview", inRepo: true, indexed: false },
-        };
-      }
-      const staleness = await assessStaleness(root);
-      const header = staleness.state === "fresh" ? "" : `⚠ index is ${staleness.state} (consider rescanning)\n`;
-      return {
-        text: header + summarizeIndex(index).join("\n"),
-        details: { action: "overview", inRepo: true, indexed: true, staleness, index },
-      };
-    }
+  const ensured = await ensureRepoIndex(root);
+  if (!ensured) {
+    return {
+      text: "The repository has no commits yet, so there is no structure to describe.",
+      details: { action: "overview", inRepo: true, indexed: false },
+    };
   }
+  const summaryCount = (await readSummaries(root)).length;
+  const footer = summaryCount > 0
+    ? `Summaries: ${summaryCount} file(s) in .okf/repository/summaries/`
+    : "Summaries: none yet — /weave-scan writes them with the session model";
+  return {
+    text: [...summarizeIndex(ensured.index), footer].join("\n"),
+    details: { action: "overview", inRepo: true, indexed: true, index: ensured.index, summaryCount },
+  };
 }

package/src/core/repoIndex.ts

@@ -368,6 +368,44 @@ export async function assessStaleness(repoRoot: string): Promise<StalenessReport
   return { state: reasons.length === 0 ? "fresh" : "stale", reasons };
 }
 
+/**
+ * The index as plumbing: read it, and rebuild it on disk when it is missing
+ * or stale. Nothing asks the user to run a structure scan any more; whoever
+ * needs the index (deep scan, graph, `weave_repo overview`) calls this.
+ * Null when the repository has no commits yet.
+ */
+export async function ensureRepoIndex(
+  root: string,
+): Promise<{ index: RepoIndex; staleness: StalenessReport } | null> {
+  const staleness = await assessStaleness(root);
+  if (staleness.state === "fresh") {
+    const index = await readRepoIndex(root);
+    // `.okf` is excluded from git, so summaries written or pruned by a deep
+    // scan never make the index stale; compare the derived-file inventory
+    // directly so the graph's `.okf` subtree keeps up.
+    if (index && sameFiles(index.structure.okFiles ?? [], await listOkfFiles(root))) return { index, staleness };
+  }
+  let index = await buildRepoIndex(root);
+  if (!index) return null;
+  try {
+    await writeRepoIndex(root, index);
+    // The first write creates the very files the inventory lists; capture
+    // them once more so the next call finds the index settled.
+    if (!sameFiles(index.structure.okFiles ?? [], await listOkfFiles(root))) {
+      index = (await buildRepoIndex(root)) ?? index;
+      await writeRepoIndex(root, index);
+    }
+  } catch {
+    // A read-only checkout still gets a current in-memory index; only the
+    // on-disk cache is skipped.
+  }
+  return { index, staleness: { state: "fresh", reasons: [] } };
+}
+
+function sameFiles(a: readonly string[], b: readonly string[]): boolean {
+  return a.length === b.length && a.every((file, i) => file === b[i]);
+}
+
 /**
  * Read a manifest provenance field, defaulting unknown/missing values to
  * "generated": every repository index written before the field existed was

package/src/core/trail.ts

@@ -0,0 +1,124 @@
+/**
+ * The recall trail: which notes the agent searched, read and wrote, in order.
+ *
+ * Agent memory is normally invisible — you cannot tell whether the agent
+ * remembered, guessed, or missed the note you wrote last week. Every vault
+ * operation already passes through `executeNoteAction`, so recording there
+ * gives both harnesses (Pi and OpenCode) the same trail with no hooks.
+ *
+ * Deliberately **in memory only**. The trail is session presentation, not
+ * knowledge: nothing here touches the vault, and a restart forgets it. The
+ * browser workspace runs in the same process as the tools, so it reads the
+ * buffer directly (`GET /api/trail`).
+ *
+ * ## Turns
+ *
+ * A turn is one user prompt's worth of agent work. Pi says so explicitly
+ * (`agent_start` calls {@link RecallTrail.beginTurn}); a harness that never
+ * does falls back to a time gap, so a pause of {@link TURN_GAP_MS} between
+ * operations starts a new turn.
+ */
+
+/** How the agent touched a note. */
+export type TrailKind = "searched" | "read" | "wrote";
+
+/** One recorded operation. `slugs` may be empty for a search with no hits. */
+export interface TrailEvent {
+  /** Monotonic per buffer; the client's stable key. */
+  seq: number;
+  turn: number;
+  /** ISO timestamp. */
+  at: string;
+  kind: TrailKind;
+  /** The `weave_note` action that produced it (`search`, `append`, …). */
+  action: string;
+  slugs: string[];
+  query?: string;
+  /** The vault the operation ran against, so a server can filter to its own. */
+  vault: string;
+}
+
+/** What a reader gets: the buffer plus a stamp that moves whenever it does. */
+export interface TrailSnapshot {
+  stamp: string;
+  turn: number;
+  events: TrailEvent[];
+}
+
+/** What a caller hands to {@link RecallTrail.record}. */
+export interface TrailEntry {
+  kind: TrailKind;
+  action: string;
+  slugs: readonly string[];
+  query?: string | undefined;
+  vault: string;
+  at: Date;
+}
+
+/** Old events fall off the front; a few hundred is far more than any viewer shows. */
+export const TRAIL_CAPACITY = 200;
+
+/** Without explicit turn boundaries, this much quiet starts a new turn. */
+export const TURN_GAP_MS = 120_000;
+
+export class RecallTrail {
+  private events: TrailEvent[] = [];
+  private seq = 0;
+  private turn = 0;
+  private explicit = false;
+  private lastAt = Number.NEGATIVE_INFINITY;
+
+  constructor(
+    private readonly capacity = TRAIL_CAPACITY,
+    private readonly gapMs = TURN_GAP_MS,
+  ) {}
+
+  /** Start a new turn. Once called, the time-gap fallback is off for good. */
+  beginTurn(): void {
+    this.explicit = true;
+    this.turn += 1;
+  }
+
+  record(entry: TrailEntry): void {
+    const at = entry.at.getTime();
+    if (this.turn === 0 || (!this.explicit && at - this.lastAt > this.gapMs)) this.turn += 1;
+    this.lastAt = at;
+    this.seq += 1;
+    this.events.push({
+      seq: this.seq,
+      turn: this.turn,
+      at: entry.at.toISOString(),
+      kind: entry.kind,
+      action: entry.action,
+      slugs: [...new Set(entry.slugs)],
+      ...(entry.query !== undefined ? { query: entry.query } : {}),
+      vault: entry.vault,
+    });
+    if (this.events.length > this.capacity) this.events.splice(0, this.events.length - this.capacity);
+  }
+
+  /** Distinct notes read or written in the current turn — the "used N notes" count. */
+  usedThisTurn(): number {
+    const used = new Set<string>();
+    for (const event of this.events) {
+      if (event.turn === this.turn && event.kind !== "searched") for (const slug of event.slugs) used.add(`${event.vault}\0${slug}`);
+    }
+    return used.size;
+  }
+
+  snapshot(): TrailSnapshot {
+    return { stamp: `${this.turn}.${this.seq}`, turn: this.turn, events: this.events.map((event) => ({ ...event, slugs: [...event.slugs] })) };
+  }
+
+  /** Forget everything. For tests and a fresh session. */
+  clear(): void {
+    this.events = [];
+    this.seq = 0;
+    this.turn = 0;
+    this.explicit = false;
+    this.lastAt = Number.NEGATIVE_INFINITY;
+  }
+}
+
+/** The process-wide trail the tools write and the workspace server reads. */
+export const recallTrail = new RecallTrail();

package/src/core/types.ts

@@ -194,9 +194,7 @@ export interface VaultStatus {
 export interface RepoStatus {
   root: string;
   name: string;
-  indexed: boolean;
-  staleness: StalenessReport;
-  /** Deep-scan summaries on disk (docs/scan-modes.md); 0 when none indexed. */
+  /** Deep-scan summaries on disk (docs/scan-modes.md); 0 before the first /weave-scan. */
   summaryCount: number;
 }
 

package/src/core/vault.ts

@@ -10,7 +10,19 @@ import {
   unquoteField,
   upsertFrontMatterFields,
 } from "./frontmatter";
-import { auditLinks, fenceRanges, rawTailStart, rewriteLinks, RAW_NOTES_HEADING, type LinkAudit, type LinkFix } from "./links/repair";
+import { auditLinks, rewriteLinks, RAW_NOTES_HEADING, type LinkAudit, type LinkFix } from "./links/repair";
+import { joinRawTail, rawTailBoundary, splitRawTail } from "./view/rawTail";
+import {
+  moveHistory,
+  readHistory,
+  moveHistoryFolder,
+  recordRevision,
+  removeHistory,
+  removeHistoryFolder,
+  type HistoryAuthor,
+  type HistoryOp,
+  type NoteRevision,
+} from "./history";
 import { withMutationQueue } from "./mutex";
 import { NOTES_DIR, OKF_MANIFEST } from "./paths";
 import { slugify, uniqueSlug } from "./slug";
@@ -37,6 +49,14 @@ export interface AddNoteInput {
   body: string;
   tags?: string[];
   source?: NoteSource;
+  /**
+   * Start the note with `body` as its first verbatim block in the `## Raw`
+   * tail instead of as editorial body. Dictation starts here, so a later
+   * `finalize` cannot replace the user's opening words.
+   */
+  raw?: boolean;
+  /** Who is creating it, for note history. Defaults from `source`. */
+  by?: HistoryAuthor;
   /** Injectable clock for tests. */
   now?: Date;
 }
@@ -104,7 +124,8 @@ export function resolveNotePath(root: string, slug: string): string | null {
 export async function addNote(root: string, input: AddNoteInput): Promise<Note> {
   await ensureVault(root);
   return withVaultLock(root, async () => {
-    const now = (input.now ?? new Date()).toISOString();
+    const date = input.now ?? new Date();
+    const now = date.toISOString();
     const base = slugify(input.title);
     const slug = uniqueSlug(base, (candidate) => existsSync(notePath(root, candidate)));
 
@@ -117,7 +138,12 @@ export async function addNote(root: string, input: AddNoteInput): Promise<Note>
     };
     // No `frontMatter`: a brand-new note has no prior layout to respect, so
     // the serializer writes its canonical block.
-    return writeNote(notePath(root, slug), slug, meta, input.body, undefined);
+    const body = input.raw && input.body.trim() !== ""
+      ? `${rawTailOpening()}\n\n${formatRawAppend(input.body, date)}\n`
+      : input.body;
+    const note = await writeNote(notePath(root, slug), slug, meta, body, undefined);
+    await record(root, note, input.by ?? (meta.source === "human" ? "human" : "agent"), "create", null, now);
+    return note;
   });
 }
 
@@ -175,6 +201,24 @@ async function writeNote(
   return { slug, ...parsed.meta, body: parsed.body, frontMatter: parsed.frontMatter };
 }
 
+/** The body a write is about to replace, and when it was last written. */
+async function priorBody(path: string, note: Note): Promise<{ body: string; at: string }> {
+  const st = await fs.stat(path).catch(() => null);
+  return { body: note.body, at: st?.mtime.toISOString() ?? note.updated };
+}
+
+/** Add the written note to its history (see `history.ts`). */
+function record(
+  root: string,
+  note: Note,
+  by: HistoryAuthor,
+  op: HistoryOp,
+  before: { body: string; at: string } | null,
+  at: string,
+): Promise<void> {
+  return recordRevision(root, note.slug, { by, op, before, after: note.body, at: new Date(at) });
+}
+
 /**
  * Namespace prefix for this module's mutation-queue keys.
  *
@@ -213,6 +257,8 @@ export interface AppendToNoteOptions {
    * editorial body above the tail.
    */
   raw?: boolean;
+  /** Who is appending, for note history. Defaults to `agent`. */
+  by?: HistoryAuthor;
 }
 
 /** Append Markdown to an existing note and bump `updated`. */
@@ -228,6 +274,7 @@ export async function appendToNote(
   return withVaultLock(root, async () => {
     const note = await getNote(root, slug);
     if (!note) return null;
+    const before = await priorBody(path, note);
     const tail = extractRawTail(note.body);
     let body: string;
     if (options.raw) {
@@ -248,7 +295,9 @@ export async function appendToNote(
       const head = note.body.slice(0, idx).replace(/\s+$/, "");
       body = (head ? head + "\n\n" : "") + addition.trim() + "\n\n" + tail + "\n";
     }
-    return writeNote(path, slug, { ...note, updated: now.toISOString() }, body, note.frontMatter);
+    const written = await writeNote(path, slug, { ...note, updated: now.toISOString() }, body, note.frontMatter);
+    await record(root, written, options.by ?? "agent", options.raw ? "raw" : "append", before, written.updated);
+    return written;
   });
 }
 
@@ -321,6 +370,8 @@ export interface FinalizeNoteInput {
    * entities, links). The `## Raw` tail is preserved verbatim beneath it.
    */
   body: string;
+  /** Who is finalizing, for note history. Defaults to `agent`. */
+  by?: HistoryAuthor;
   /** Injectable clock for tests. */
   now?: Date;
 }
@@ -354,7 +405,10 @@ export async function finalizeNote(
           ? ""
           : `\n\n${rawTailOpening()}\n\n${fenceFor(note.body)}\n${note.body.trim()}\n${fenceFor(note.body)}`);
     const meta: NoteMeta = { ...note, updated: (input.now ?? new Date()).toISOString() };
-    return writeNote(path, slug, meta, body, note.frontMatter);
+    const before = await priorBody(path, note);
+    const written = await writeNote(path, slug, meta, body, note.frontMatter);
+    await record(root, written, input.by ?? "agent", "finalize", before, meta.updated);
+    return written;
   });
 }
 
@@ -373,7 +427,8 @@ export interface UpsertNoteInput {
 export async function upsertNote(root: string, input: UpsertNoteInput): Promise<Note> {
   await ensureVault(root);
   return withVaultLock(root, async () => {
-    const now = (input.now ?? new Date()).toISOString();
+    const date = input.now ?? new Date();
+    const now = date.toISOString();
     const identity = input.identity;
     let existing = await getNote(root, input.slug);
     if (existing !== null && identity && frontMatterField(existing.frontMatter, identity.field) !== identity.value) {
@@ -400,7 +455,9 @@ export async function upsertNote(root: string, input: UpsertNoteInput): Promise<
         `source: ${meta.source}`,
         ...upsertFrontMatterFields([], fields),
       ];
-      return writeNote(notePath(root, slug), slug, meta, input.body, frontMatter);
+      const created = await writeNote(notePath(root, slug), slug, meta, input.body, frontMatter);
+      await record(root, created, "agent", "generate", null, now);
+      return created;
     }
     const fields = safeGeneratedFields(input.fields);
     const frontMatter = upsertFrontMatterFields(existing.frontMatter ?? [], fields);
@@ -410,13 +467,16 @@ export async function upsertNote(root: string, input: UpsertNoteInput): Promise<
     // verbatim tail.
     const tail = extractRawTail(existing.body);
     const body = tail === "" ? input.body.trim() : `${input.body.trim()}\n\n${tail}`;
-    return writeNote(
+    const before = await priorBody(notePath(root, input.slug), existing);
+    const refreshed = await writeNote(
       notePath(root, input.slug),
       input.slug,
       { ...existing, updated: now },
       body,
       frontMatter,
     );
+    await record(root, refreshed, "agent", "generate", before, now);
+    return refreshed;
   });
 }
 
@@ -515,6 +575,7 @@ async function rewriteVaultLinks(
     } catch {
       continue; // raced a delete
     }
+    const before = await priorBody(path, note);
     const at = original.lastIndexOf(note.body);
     if (at === -1) continue; // body not found verbatim; refuse rather than guess
     const next = original.slice(0, at) + body + original.slice(at + note.body.length);
@@ -532,6 +593,8 @@ async function rewriteVaultLinks(
       await fs.writeFile(tmp, next, "utf8");
       await fs.rename(tmp, path);
     }
+    const repaired = await getNote(root, slug);
+    if (repaired !== null) await record(root, repaired, "system", "repair", before, new Date().toISOString());
     touched.push(slug);
     links += changed;
   }
@@ -598,30 +661,24 @@ export async function repairVaultLinks(root: string, options: { apply?: boolean
 
 /**
  * Keep the on-disk `## Raw` tail whatever the body says — it is append-only.
- * `rawTailStart`, not `extractRawTail`: fence-aware, for untrusted input.
+ * `rawTailBoundary`, not `extractRawTail`: fence-aware, for untrusted input.
  */
 function preserveRawTail(currentBody: string, nextBody: string): string {
-  const tail = currentBody.slice(tailBoundary(currentBody)).trimEnd();
-  const head = nextBody.slice(0, tailBoundary(nextBody)).trim();
-  if (tail === "") return head;
-  // An emptied head leaves the tail alone, not a leading blank line.
-  return head === "" ? tail : `${head}\n\n${tail}`;
+  const tail = currentBody.slice(rawTailBoundary(currentBody)).trimEnd();
+  return joinRawTail(nextBody.slice(0, rawTailBoundary(nextBody)).trim(), tail);
 }
 
-/** A `---` rule, alone on the line, with only blank space after it. */
-const TAIL_RULE_RE = /(?:^|\n)-{3,}[ \t]*\r?\n\s*$/;
-
 /**
- * Where the tail's text begins — the `---` rule, not the heading
- * `rawTailStart` returns. Splitting at the heading orphans the rule.
+ * What a body save does with the `## Raw` tail. `keep` (the default) holds
+ * the on-disk tail whatever the body says. `replace` writes the body's own
+ * tail: the person editing the note changed their own Raw words on purpose.
  */
-function tailBoundary(body: string): number {
-  const heading = rawTailStart(body, fenceRanges(body));
-  if (heading === body.length) return heading;
-  const rule = TAIL_RULE_RE.exec(body.slice(0, heading));
-  if (rule === null) return heading;
-  // `index` is the newline before the rule when there is one; step over it.
-  return rule.index === 0 && !body.startsWith("\n") ? 0 : rule.index + 1;
+export type RawTailMode = "keep" | "replace";
+
+/** The body as sent, its tail included, with the same spacing `preserveRawTail` writes. */
+function normalizeRawTail(body: string): string {
+  const { head, tail } = splitRawTail(body);
+  return joinRawTail(head.trim(), tail);
 }
 
 /**
@@ -629,18 +686,43 @@ function tailBoundary(body: string): number {
  * `note.frontMatter` and only `updated` moves. Last write wins — no
  * `expectedRevision`; docs/weave-workspace.md §11 P5.3 argues the trade.
  */
-export async function setNoteBody(root: string, slug: string, body: string, now = new Date()): Promise<VaultMutationResult> {
+export async function setNoteBody(
+  root: string,
+  slug: string,
+  body: string,
+  now = new Date(),
+  by: HistoryAuthor = "human",
+  raw: RawTailMode = "keep",
+): Promise<VaultMutationResult> {
   const path = resolveNotePath(root, slug);
   if (path === null) return { ok: false, reason: "invalid" };
   return withVaultLock(root, async () => {
     const note = await getNote(root, slug);
     if (note === null) return { ok: false, reason: "missing" };
-    const next = preserveRawTail(note.body, body);
-    await writeNote(path, slug, { ...note, updated: now.toISOString() }, next, note.frontMatter);
+    const next = raw === "replace" ? normalizeRawTail(body) : preserveRawTail(note.body, body);
+    const before = await priorBody(path, note);
+    const written = await writeNote(path, slug, { ...note, updated: now.toISOString() }, next, note.frontMatter);
+    await record(root, written, by, "edit", before, written.updated);
     return { ok: true, slug };
   });
 }
 
+/**
+ * Every saved revision of a note, ending on what the note says now, or null
+ * when the note is missing. Under the vault lock, so a write cannot land
+ * between reading the note and comparing it with its log: that window would
+ * record the old body as an outside edit.
+ */
+export async function readNoteHistory(root: string, slug: string): Promise<NoteRevision[] | null> {
+  const path = resolveNotePath(root, slug);
+  if (path === null) return null;
+  return withVaultLock(root, async () => {
+    const note = await getNote(root, slug);
+    if (note === null) return null;
+    return readHistory(root, slug, await priorBody(path, note));
+  });
+}
+
 /** Rename a note in place and keep its front-matter title in sync. */
 export async function renameNote(root: string, slug: string, name: string, now = new Date()): Promise<VaultMutationResult> {
   const from = resolveNotePath(root, slug);
@@ -656,6 +738,7 @@ export async function renameNote(root: string, slug: string, name: string, now =
     if (from !== to && await exists(to)) return { ok: false, reason: "collision" };
     if (from !== to) await fs.rename(from, to);
     await writeNote(to, target, { ...note, title, updated: now.toISOString() }, note.body, note.frontMatter);
+    if (from !== to) await moveHistory(root, slug, target);
     if (from !== to) await repointBacklinks(root, new Map([[slug, target]]));
     return { ok: true, slug: target };
   });
@@ -675,6 +758,7 @@ export async function moveNote(root: string, slug: string, folder: string | null
     if (from === to) return { ok: true, slug };
     if (await exists(to)) return { ok: false, reason: "collision" };
     await fs.rename(from, to);
+    await moveHistory(root, slug, target);
     await repointBacklinks(root, new Map([[slug, target]]));
     return { ok: true, slug: target };
   });
@@ -687,6 +771,7 @@ export async function deleteNote(root: string, slug: string): Promise<VaultMutat
   return withVaultLock(root, async () => {
     if (!(await exists(path))) return { ok: false, reason: "missing" };
     await fs.unlink(path);
+    await removeHistory(root, slug);
     return { ok: true };
   });
 }
@@ -711,6 +796,7 @@ export async function renameFolder(root: string, folder: string, name: string):
       .filter((f) => isMarkdown(f) && f.startsWith(`${folder}/`))
       .map((f) => f.slice(0, -".md".length));
     await fs.rename(from, to);
+    await moveHistoryFolder(root, folder, target);
     await repointBacklinks(root, new Map(moved.map((s) => [s, `${target}/${s.slice(folder.length + 1)}`])));
     return { ok: true, path: target };
   });
@@ -723,6 +809,7 @@ export async function deleteFolder(root: string, folder: string): Promise<VaultM
   return withVaultLock(root, async () => {
     if (!(await isDirectory(path))) return { ok: false, reason: "missing" };
     await fs.rm(path, { recursive: true });
+    await removeHistoryFolder(root, folder);
     return { ok: true };
   });
 }

package/src/core/view/focus.ts

@@ -1,8 +1,8 @@
 /**
  * focusModel — the 1-hop neighborhood of a node, grouped (weave-workspace §3).
  *
- * The TUI renders this as the Focus surface; the browser workspace uses
- * `focusNeighborhood` for the graph's neighborhood highlight.
+ * The browser workspace uses `focusNeighborhood` for the graph's
+ * neighborhood highlight.
  */
 
 import type { GraphEdge, GraphModel, GraphNode, NodeKind } from "../graph/model";

package/src/core/view/index.ts

@@ -1,8 +1,8 @@
 /**
  * src/core/view — portable, renderer-agnostic view-models (weave-workspace §3).
  *
- * One implementation of the tree, detail, focus, and health projections, shared
- * by the pi TUI and the browser workspace so they can never drift. Pure
+ * One implementation of the tree, detail, focus, and cluster projections,
+ * written once so every surface that renders them agrees. Pure
  * functions over `GraphModel`; no harness, no DOM, no terminal concepts.
  */
 export * from "./types";
@@ -11,5 +11,4 @@ export * from "./tree";
 export * from "./detail";
 export * from "./focus";
 export * from "./links";
-export * from "./health";
 export * from "./cluster";