sidediff 0.2.2 → 0.3.0

package/README.md

@@ -51,6 +51,21 @@ sidediff note clear [--file src/app.ts]
 
 Notes are stored one file per note under `<git dir>/sidediff/notes`, so concurrent writers never collide and nothing is committed to the repository.
 
+## Review threads
+
+Hover a line in the diff and press `+` to start a thread on it. Every note is a thread: it lists its replies and has a reply box and Resolve. Threads, replies and resolved state are saved with the note, so they survive restarts.
+
+The agent side talks to the running server, so the page updates the moment it replies:
+
+```sh
+sidediff threads [--after <seq>] [--wait 600] [--all]   # blocks until the reviewer starts a thread, replies or resolves
+sidediff thread <id>                                    # print a thread: the first comment and every reply
+sidediff reply <id> "text"                              # reply as the agent
+sidediff resolve <id> [--reopen]
+```
+
+`sidediff threads` prints `seq  kind  note-id  file:line  author: text` and skips the agent's own events unless `--all` is passed. Pass the last `seq` as `--after` to pick up where you left off. Threads started in the page are attributed to `git config user.name`.
+
 ## Guided tours and conversation
 
 A running server accepts commands that drive the open page, so a person or an agent can walk someone through a change:

package/dist/cli.js

@@ -4,6 +4,7 @@ import { Console, Context, Duration, Effect, FileSystem, Layer, Option, Schema,
 import { Argument, Command, Flag } from 'effect/cli';
 import { ChildProcess, ChildProcessSpawner } from 'effect/process';
 import { RpcClient, RpcSerialization } from 'effect/rpc';
+import { createRequire } from 'node:module';
 import { Git } from './git.js';
 import { Notes } from './notes.js';
 import { NoteBatch, SidediffRpcs, Steps } from './protocol.js';
@@ -65,6 +66,7 @@ const listen = Command.make('listen', {
     const heard = yield* client.Listen(after === undefined ? {} : { after }).pipe(Stream.take(1), Stream.runHead, Effect.timeoutOption(Duration.seconds(wait)), Effect.map(Option.flatten));
     yield* Effect.forEach(Option.getOrElse(heard, () => []), (utterance) => Console.log(`${utterance.id}\t${utterance.text}`));
 }).pipe(withClient)).pipe(Command.withDescription('wait for the next thing said into the mic'));
+const serverOr = (remote, local) => Client.use(remote).pipe(withClient, Effect.catchTag(['NoServer', 'RpcClientError'], () => local));
 const noteAdd = Command.make('add', {
     file: Flag.String('file'),
     newLine: Flag.Int('new-line').pipe(Flag.optional, Flag.map(Option.getOrUndefined)),
@@ -73,35 +75,60 @@ const noteAdd = Command.make('add', {
     rationale: optionalText('rationale'),
     author: optionalText('author'),
 }, ({ file, newLine, oldLine, summary, rationale, author }) => Effect.gen(function* () {
-    const notes = yield* Notes;
-    const [note] = yield* notes.add([
-        { filePath: file, summary, ...defined({ newLine, oldLine, rationale, author }) },
-    ]);
+    const input = { filePath: file, summary, ...defined({ newLine, oldLine, rationale, author }) };
+    const [note] = yield* serverOr((client) => client.AddNotes({ notes: [input] }), Notes.use((notes) => notes.add([input])));
     yield* Console.log(`added ${note?.id} on ${note?.filePath}:${note?.line}`);
 })).pipe(Command.withDescription('add one note'));
 const noteApply = Command.make('apply', {}, () => Effect.gen(function* () {
     const stdio = yield* Stdio.Stdio;
-    const notes = yield* Notes;
     const text = yield* Stream.mkString(Stream.decodeText(stdio.stdin));
     const batch = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(NoteBatch))(text);
-    const added = yield* notes.add('comments' in batch ? batch.comments : batch);
+    const inputs = 'comments' in batch ? batch.comments : batch;
+    const added = yield* serverOr((client) => client.AddNotes({ notes: inputs }), Notes.use((notes) => notes.add(inputs)));
     yield* Console.log(`added ${added.length} notes`);
 })).pipe(Command.withDescription('add a batch from stdin: {"comments":[{filePath,newLine|oldLine,summary,...}]}'));
 const noteList = Command.make('list', { json: Flag.Boolean('json').pipe(Flag.withDefault(false)), file: optionalText('file') }, ({ json, file }) => Effect.gen(function* () {
-    const notes = yield* Notes;
-    const shown = (yield* notes.list).filter((note) => file === undefined || note.filePath === file);
+    const all = yield* serverOr((client) => client.ListNotes(), Notes.use((notes) => notes.list));
+    const shown = all.filter((note) => file === undefined || note.filePath === file);
     if (json)
         return yield* Console.log(JSON.stringify(shown, null, 2));
     yield* Effect.forEach(shown, (note) => Console.log(`${note.id}  ${note.filePath}:${note.line}  ${note.summary}`));
 })).pipe(Command.withDescription('list notes'));
+const eventLine = (event) => `${event.seq}\t${event.kind}\t${event.noteId}\t${event.filePath}:${event.line}\t${event.author}: ${event.body}`;
+const threads = Command.make('threads', {
+    after: Flag.Int('after').pipe(Flag.optional, Flag.map(Option.getOrUndefined)),
+    wait: Flag.Int('wait').pipe(Flag.withDefault(600)),
+    all: Flag.Boolean('all').pipe(Flag.withDefault(false)),
+}, ({ after, wait, all }) => Effect.gen(function* () {
+    const client = yield* Client;
+    const next = yield* client.Threads(after === undefined ? {} : { after }).pipe(Stream.map((batch) => batch.filter((event) => all || event.author !== 'agent')), Stream.filter((batch) => batch.length > 0), Stream.take(1), Stream.runHead, Effect.timeoutOption(Duration.seconds(wait)), Effect.map(Option.flatten));
+    yield* Effect.forEach(Option.getOrElse(next, () => []), (event) => Console.log(eventLine(event)), {
+        discard: true,
+    });
+}).pipe(withClient)).pipe(Command.withDescription('wait for the next review thread, reply or resolve from the reviewer; prints seq, kind, note id, file:line and text'));
+const thread = Command.make('thread', { id: Argument.String('id') }, ({ id }) => Effect.gen(function* () {
+    const all = yield* serverOr((client) => client.ListNotes(), Notes.use((notes) => notes.list));
+    const found = all.find((note) => note.id === id);
+    if (found === undefined)
+        return yield* Console.error(`no note ${id}`);
+    yield* Console.log(`${found.filePath}:${found.line}${found.resolved === true ? '  (resolved)' : ''}`);
+    yield* Console.log(`${found.author}: ${found.summary}`);
+    yield* Effect.forEach(found.replies ?? [], (entry) => Console.log(`${entry.author}: ${entry.body}`), {
+        discard: true,
+    });
+})).pipe(Command.withDescription('print a thread: the first comment and every reply'));
+const reply = Command.make('reply', {
+    id: Argument.String('id'),
+    text: Argument.String('text').pipe(Argument.variadic({ min: 1 })),
+    author: Flag.String('author').pipe(Flag.withDefault('agent')),
+}, ({ id, text, author }) => Client.use((client) => client.Reply({ noteId: id, body: text.join(' '), author })).pipe(Effect.flatMap((note) => Console.log(`replied on ${note.id} (${note.replies?.length ?? 0} replies)`)), withClient)).pipe(Command.withDescription('reply to a review thread; it appears in the browser immediately'));
+const resolve = Command.make('resolve', { id: Argument.String('id'), reopen: Flag.Boolean('reopen').pipe(Flag.withDefault(false)) }, ({ id, reopen }) => Client.use((client) => client.Resolve({ noteId: id, resolved: !reopen, author: 'agent' })).pipe(Effect.flatMap((note) => Console.log(`${note.id} ${note.resolved === true ? 'resolved' : 'reopened'}`)), withClient)).pipe(Command.withDescription('resolve a review thread, or reopen it with --reopen'));
 const noteRemove = Command.make('rm', { id: Argument.String('id') }, ({ id }) => Effect.gen(function* () {
-    const notes = yield* Notes;
-    yield* notes.remove(id);
+    yield* serverOr((client) => client.RemoveNote({ id }), Notes.use((notes) => notes.remove(id)));
     yield* Console.log(`removed ${id}`);
 })).pipe(Command.withDescription('remove a note'));
 const noteClear = Command.make('clear', { file: optionalText('file') }, ({ file }) => Effect.gen(function* () {
-    const notes = yield* Notes;
-    const count = yield* notes.clear(file);
+    const count = yield* serverOr((client) => client.ClearNotes(file === undefined ? {} : { filePath: file }), Notes.use((notes) => notes.clear(file)));
     yield* Console.log(`cleared ${count} notes`);
 })).pipe(Command.withDescription('remove every note, or every note on one file'));
 const note = Command.make('note').pipe(Command.withDescription('notes live in <git dir>/sidediff/notes and appear in the browser as they are written'), Command.withSubcommands([noteAdd, noteApply, noteList, noteRemove, noteClear]));
@@ -120,6 +147,24 @@ const sidediff = Command.make('sidediff', {
     const chosen = yield* freePort(port, host);
     const url = `http://${host}:${chosen}`;
     yield* Layer.launch(serverLayer({ range, port: chosen, host, watch }).pipe(Layer.merge(Layer.effectDiscard(Effect.andThen(Console.log(`sidediff: ${url}  (${watch ? 'watching for changes' : 'watch off'})`), open ? openBrowser(url) : Effect.void)))));
-})).pipe(Command.withDescription('GitHub-style diff review in the browser, with a live notes column'), Command.withSubcommands([note, show, highlight, explain, say, clear, tour, next, back, goto, where, listen]));
+})).pipe(Command.withDescription('GitHub-style diff review in the browser, with a live notes column'), Command.withSubcommands([
+    note,
+    show,
+    highlight,
+    explain,
+    say,
+    clear,
+    tour,
+    next,
+    back,
+    goto,
+    where,
+    listen,
+    threads,
+    thread,
+    reply,
+    resolve,
+]));
 const AppLayer = Notes.layer.pipe(Layer.provideMerge(Repo.layer), Layer.provideMerge(Git.layer), Layer.provideMerge(NodeServices.layer));
-Command.run(sidediff, { version: '0.2.0' }).pipe(Effect.provide(AppLayer), NodeRuntime.runMain);
+const { version } = createRequire(import.meta.url)('../package.json');
+Command.run(sidediff, { version }).pipe(Effect.provide(AppLayer), NodeRuntime.runMain);

package/dist/notes.js

@@ -1,5 +1,5 @@
-import { Context, DateTime, Effect, FileSystem, Layer, Option, Path, Random, Schema } from 'effect';
-import { Note } from './protocol.js';
+import { Context, DateTime, Effect, FileSystem, Layer, Option, Path, Random, Schema, SubscriptionRef } from 'effect';
+import { Note, NoteMissing } from './protocol.js';
 import { Repo } from './repo.js';
 export class NoteWithoutLine extends Schema.TaggedError()('NoteWithoutLine', {
     filePath: Schema.String,
@@ -17,6 +17,7 @@ export class NotesUnwritable extends Schema.TaggedError()('NotesUnwritable', {
 }
 const decodeNote = Schema.decodeUnknownOption(Schema.fromJsonString(Note));
 const hex = (value) => value.toString(16).padStart(8, '0');
+const ordered = (notes) => notes.toSorted((a, b) => a.filePath.localeCompare(b.filePath) || a.line - b.line);
 export class Notes extends Context.Service()('sidediff/Notes') {
     static layer = Layer.effect(Notes, Effect.gen(function* () {
         const fs = yield* FileSystem.FileSystem;
@@ -25,7 +26,17 @@ export class Notes extends Context.Service()('sidediff/Notes') {
         const unwritable = () => new NotesUnwritable({ directory });
         const fileOf = (id) => path.join(directory, `${id}.json`);
         const newId = Effect.map(Effect.all([Random.nextIntBetween(0, 0xffffffff), Random.nextIntBetween(0, 0xffffffff)]), ([a, b]) => `${hex(a)}${hex(b)}`);
-        const toNote = (input) => Effect.gen(function* () {
+        const names = yield* fs.readDirectory(directory).pipe(Effect.orElseSucceed(() => []));
+        const loaded = yield* Effect.forEach(names.filter((name) => name.endsWith('.json')), (name) => fs.readFileString(path.join(directory, name)).pipe(Effect.map(decodeNote), Effect.orElseSucceed(() => Option.none())), { concurrency: 16 });
+        const state = yield* SubscriptionRef.make(ordered(loaded.flatMap((note) => (Option.isSome(note) ? [note.value] : []))));
+        const write = (note) => fs.makeDirectory(directory, { recursive: true }).pipe(Effect.andThen(fs.writeFileString(fileOf(note.id), JSON.stringify(note))), Effect.mapError(unwritable));
+        const erase = (id) => fs.remove(fileOf(id), { force: true }).pipe(Effect.mapError(unwritable));
+        const put = (notes) => SubscriptionRef.update(state, (current) => ordered([...current.filter((note) => !notes.some((next) => next.id === note.id)), ...notes]));
+        const find = (id) => Effect.flatMap(SubscriptionRef.get(state), (current) => Option.match(Option.fromNullishOr(current.find((note) => note.id === id)), {
+            onNone: () => Effect.fail(new NoteMissing({ id })),
+            onSome: Effect.succeed,
+        }));
+        const toNote = Effect.fnUntraced(function* (input) {
             const line = input.newLine ?? input.oldLine;
             if (line === undefined)
                 return yield* new NoteWithoutLine({ filePath: input.filePath });
@@ -40,27 +51,48 @@ export class Notes extends Context.Service()('sidediff/Notes') {
                 ...(input.rationale === undefined ? {} : { rationale: input.rationale }),
                 author: input.author ?? 'agent',
                 createdAt: DateTime.formatIso(now),
+                ...(input.kind === undefined ? {} : { kind: input.kind }),
             };
         });
-        const list = Effect.gen(function* () {
-            const names = yield* fs.readDirectory(directory).pipe(Effect.orElseSucceed(() => []));
-            const read = yield* Effect.forEach(names.filter((name) => name.endsWith('.json')), (name) => fs.readFileString(path.join(directory, name)).pipe(Effect.map(decodeNote), Effect.orElseSucceed(() => Option.none())), { concurrency: 16 });
-            return read
-                .flatMap((note) => (Option.isSome(note) ? [note.value] : []))
-                .toSorted((a, b) => a.filePath.localeCompare(b.filePath) || a.line - b.line);
-        });
-        const remove = (id) => fs.remove(fileOf(id), { force: true }).pipe(Effect.mapError(unwritable));
-        const add = (inputs) => Effect.gen(function* () {
+        const add = Effect.fn('Notes.add')(function* (inputs) {
             const created = yield* Effect.forEach(inputs, toNote);
-            yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.mapError(unwritable));
-            yield* Effect.forEach(created, (note) => fs.writeFileString(fileOf(note.id), JSON.stringify(note)).pipe(Effect.mapError(unwritable)), { concurrency: 16, discard: true });
+            yield* Effect.forEach(created, write, { concurrency: 16, discard: true });
+            yield* put(created);
             return created;
         });
-        const clear = (filePath) => Effect.gen(function* () {
-            const doomed = (yield* list).filter((note) => filePath === undefined || note.filePath === filePath);
-            yield* Effect.forEach(doomed, (note) => remove(note.id), { concurrency: 16, discard: true });
+        const remove = Effect.fn('Notes.remove')(function* (id) {
+            yield* erase(id);
+            yield* SubscriptionRef.update(state, (current) => current.filter((note) => note.id !== id));
+        });
+        const clear = Effect.fn('Notes.clear')(function* (filePath) {
+            const doomed = (yield* SubscriptionRef.get(state)).filter((note) => filePath === undefined || note.filePath === filePath);
+            yield* Effect.forEach(doomed, (note) => erase(note.id), { concurrency: 16, discard: true });
+            yield* SubscriptionRef.update(state, (current) => current.filter((note) => !doomed.includes(note)));
             return doomed.length;
         });
-        return { add, list, remove, clear };
+        const change = Effect.fnUntraced(function* (id, edit) {
+            const note = yield* find(id);
+            const next = yield* edit(note);
+            yield* write(next);
+            yield* put([next]);
+            return next;
+        });
+        const reply = (id, author, body) => change(id, (note) => Effect.map(Effect.all([newId, DateTime.now]), ([replyId, now]) => ({
+            ...note,
+            kind: 'comment',
+            replies: [...(note.replies ?? []), { id: replyId, author, body, createdAt: DateTime.formatIso(now) }],
+        })));
+        const resolve = (id, resolved) => change(id, (note) => Effect.succeed({ ...note, resolved }));
+        const toComment = (id) => change(id, (note) => Effect.succeed({ ...note, kind: 'comment' }));
+        return Notes.of({
+            list: SubscriptionRef.get(state),
+            changes: SubscriptionRef.changes(state),
+            add,
+            remove,
+            clear,
+            reply,
+            resolve,
+            toComment,
+        });
     }));
 }

package/dist/protocol.js

@@ -2,6 +2,14 @@ import { Schema } from 'effect';
 import { Rpc, RpcGroup } from 'effect/rpc';
 export const Side = Schema.Literals(['additions', 'deletions']);
 const Line = Schema.Int.check(Schema.isGreaterThan(0));
+export const NoteKind = Schema.Literals(['annotation', 'comment']);
+export const isComment = (note) => note.kind === 'comment';
+export const Reply = Schema.Struct({
+    id: Schema.String,
+    author: Schema.String,
+    body: Schema.NonEmptyString,
+    createdAt: Schema.String,
+});
 export const Note = Schema.Struct({
     id: Schema.String,
     filePath: Schema.String,
@@ -11,6 +19,9 @@ export const Note = Schema.Struct({
     rationale: Schema.optionalKey(Schema.String),
     author: Schema.String,
     createdAt: Schema.String,
+    replies: Schema.optionalKey(Schema.Array(Reply)),
+    resolved: Schema.optionalKey(Schema.Boolean),
+    kind: Schema.optionalKey(NoteKind),
 });
 export const NoteInput = Schema.Struct({
     filePath: Schema.NonEmptyString,
@@ -19,6 +30,7 @@ export const NoteInput = Schema.Struct({
     summary: Schema.NonEmptyString,
     rationale: Schema.optionalKey(Schema.String),
     author: Schema.optionalKey(Schema.String),
+    kind: Schema.optionalKey(NoteKind),
 });
 export const NoteBatch = Schema.Union([
     Schema.Array(NoteInput),
@@ -31,6 +43,7 @@ export const Snapshot = Schema.Struct({
     patch: Schema.String,
     notes: Schema.Array(Note),
     version: Schema.String,
+    diffVersion: Schema.String,
     watching: Schema.Boolean,
     updatedAt: Schema.String,
 });
@@ -75,6 +88,27 @@ export const Utterance = Schema.Struct({
     at: Schema.String,
     handled: Schema.Boolean,
 });
+export const ThreadEvent = Schema.Struct({
+    seq: Schema.Int,
+    kind: Schema.Literals(['thread', 'reply', 'resolved', 'reopened', 'converted']),
+    noteId: Schema.String,
+    filePath: Schema.String,
+    side: Side,
+    line: Line,
+    author: Schema.String,
+    body: Schema.String,
+    at: Schema.String,
+});
+export class NoteMissing extends Schema.TaggedError()('NoteMissing', { id: Schema.String }) {
+    get message() {
+        return `no note ${this.id}`;
+    }
+}
+export class NoteUnsaved extends Schema.TaggedError()('NoteUnsaved', { reason: Schema.String }) {
+    get message() {
+        return this.reason;
+    }
+}
 export class FileMissing extends Schema.TaggedError()('FileMissing', {
     side: Schema.Literals(['old', 'new']),
     path: Schema.String,
@@ -88,4 +122,28 @@ export const SidediffRpcs = RpcGroup.make(Rpc.make('Snapshots', { success: Snaps
     payload: { after: Schema.optionalKey(Schema.Int) },
     success: Schema.Array(Utterance),
     stream: true,
+}), Rpc.make('StartThread', {
+    payload: { filePath: Schema.NonEmptyString, side: Side, line: Line, body: Schema.NonEmptyString },
+    success: Note,
+    error: NoteUnsaved,
+}), Rpc.make('Reply', {
+    payload: { noteId: Schema.NonEmptyString, body: Schema.NonEmptyString, author: Schema.optionalKey(Schema.String) },
+    success: Note,
+    error: Schema.Union([NoteMissing, NoteUnsaved]),
+}), Rpc.make('ToComment', {
+    payload: { noteId: Schema.NonEmptyString },
+    success: Note,
+    error: Schema.Union([NoteMissing, NoteUnsaved]),
+}), Rpc.make('Resolve', {
+    payload: { noteId: Schema.NonEmptyString, resolved: Schema.Boolean, author: Schema.optionalKey(Schema.String) },
+    success: Note,
+    error: Schema.Union([NoteMissing, NoteUnsaved]),
+}), Rpc.make('Refresh', {}), Rpc.make('ListNotes', { success: Schema.Array(Note) }), Rpc.make('AddNotes', { payload: { notes: Schema.Array(NoteInput) }, success: Schema.Array(Note), error: NoteUnsaved }), Rpc.make('RemoveNote', { payload: { id: Schema.NonEmptyString }, error: NoteUnsaved }), Rpc.make('ClearNotes', {
+    payload: { filePath: Schema.optionalKey(Schema.String) },
+    success: Schema.Int,
+    error: NoteUnsaved,
+}), Rpc.make('Threads', {
+    payload: { after: Schema.optionalKey(Schema.Int) },
+    success: Schema.Array(ThreadEvent),
+    stream: true,
 }));

package/dist/server.js

@@ -8,7 +8,7 @@ import { HttpRouter, HttpServerResponse } from 'effect/http';
 import { RpcSerialization, RpcServer } from 'effect/rpc';
 import { Git } from './git.js';
 import { Notes } from './notes.js';
-import { FileMissing, SidediffRpcs } from './protocol.js';
+import { FileMissing, NoteUnsaved, SidediffRpcs, } from './protocol.js';
 import { Repo } from './repo.js';
 export class ServeOptions extends Context.Service()('sidediff/ServeOptions') {
 }
@@ -31,26 +31,22 @@ export class Review extends Context.Service()('sidediff/Review') {
         const options = yield* ServeOptions;
         const fs = yield* FileSystem.FileSystem;
         const path = yield* Path.Path;
-        const build = Effect.gen(function* () {
-            const [patch, current, branch, now] = yield* Effect.all([git.diff(repo.root, options.range), notes.list, git.branch(repo.root), DateTime.now], { concurrency: 'unbounded' });
-            return {
-                repo: repo.root,
-                branch,
-                range: options.range,
-                patch,
-                notes: current,
-                version: versionOf(patch, current),
-                watching: options.watch,
-                updatedAt: DateTime.formatIso(now),
-            };
-        });
-        const snapshot = yield* SubscriptionRef.make(yield* build);
-        const refresh = build.pipe(Effect.flatMap((next) => SubscriptionRef.update(snapshot, (current) => (current.version === next.version ? current : next))), Effect.catch((error) => Effect.logWarning('[refresh] diff failed', error)));
-        yield* fs.makeDirectory(repo.notes, { recursive: true });
-        const changes = Stream.merge(fs.watch(repo.notes), options.watch
-            ? fs.watch(repo.root, { recursive: true }).pipe(Stream.filter((event) => isRelevant(event.path)))
-            : Stream.empty);
-        yield* changes.pipe(Stream.debounce(Duration.millis(250)), Stream.runForEach(() => refresh), Effect.catch((error) => Effect.logWarning('[watch] stopped', error)), Effect.forkScoped);
+        const readPatch = Effect.map(Effect.all([git.diff(repo.root, options.range), git.branch(repo.root)], { concurrency: 'unbounded' }), ([patch, branch]) => ({ patch, branch }));
+        const diff = yield* SubscriptionRef.make(yield* readPatch);
+        const refresh = readPatch.pipe(Effect.flatMap((next) => SubscriptionRef.update(diff, (current) => (current.patch === next.patch ? current : next))), Effect.catch((error) => Effect.logWarning('[refresh] diff failed', error)));
+        const snapshots = Stream.zipLatest(SubscriptionRef.changes(diff), notes.changes).pipe(Stream.mapEffect(([{ patch, branch }, current]) => Effect.map(DateTime.now, (now) => ({
+            repo: repo.root,
+            branch,
+            range: options.range,
+            patch,
+            notes: current,
+            version: versionOf(patch, current),
+            diffVersion: versionOf(patch, []),
+            watching: options.watch,
+            updatedAt: DateTime.formatIso(now),
+        }))));
+        if (options.watch)
+            yield* fs.watch(repo.root, { recursive: true }).pipe(Stream.filter((event) => isRelevant(event.path)), Stream.debounce(Duration.millis(250)), Stream.runForEach(() => refresh), Effect.catch((error) => Effect.logWarning('[watch] stopped', error)), Effect.forkScoped);
         const commands = yield* PubSub.unbounded();
         const watchers = yield* Ref.make(0);
         const views = yield* Ref.make(null);
@@ -84,8 +80,68 @@ export class Review extends Context.Service()('sidediff/Review') {
             const live = Stream.fromPubSub(spoken).pipe(Stream.filter((utterance) => utterance.id > since), Stream.map((utterance) => [utterance]));
             return pending.length > 0 ? Stream.concat(Stream.make(pending), live) : live;
         }));
+        const reviewer = yield* git.run(repo.root, ['config', 'user.name']).pipe(Effect.map((name) => name.trim()), Effect.map((name) => (name === '' ? 'reviewer' : name)), Effect.orElseSucceed(() => 'reviewer'));
+        const events = yield* Ref.make([]);
+        const threadEvents = yield* PubSub.unbounded();
+        const unsaved = (error) => new NoteUnsaved({ reason: error.message });
+        const record = Effect.fnUntraced(function* (kind, note, author, body) {
+            const now = yield* DateTime.now;
+            const event = yield* Ref.modify(events, (all) => {
+                const next = {
+                    seq: all.length + 1,
+                    kind,
+                    noteId: note.id,
+                    filePath: note.filePath,
+                    side: note.side,
+                    line: note.line,
+                    author,
+                    body,
+                    at: DateTime.formatIso(now),
+                };
+                return [next, [...all, next]];
+            });
+            yield* PubSub.publish(threadEvents, event);
+            return note;
+        });
+        const startThread = Effect.fn('Review.startThread')(function* (input) {
+            const lineKey = input.side === 'deletions' ? { oldLine: input.line } : { newLine: input.line };
+            const [note] = yield* notes
+                .add([{ filePath: input.filePath, ...lineKey, summary: input.body, author: reviewer, kind: 'comment' }])
+                .pipe(Effect.mapError(unsaved));
+            if (note === undefined)
+                return yield* new NoteUnsaved({ reason: 'the thread was not created' });
+            return yield* record('thread', note, reviewer, input.body);
+        });
+        const reply = Effect.fn('Review.reply')(function* (id, body, author) {
+            const who = author ?? reviewer;
+            const note = yield* notes.reply(id, who, body).pipe(Effect.catchTag('NotesUnwritable', (error) => Effect.fail(unsaved(error))));
+            return yield* record('reply', note, who, body);
+        });
+        const resolve = Effect.fn('Review.resolve')(function* (id, resolved, author) {
+            const who = author ?? reviewer;
+            const note = yield* notes.resolve(id, resolved).pipe(Effect.catchTag('NotesUnwritable', (error) => Effect.fail(unsaved(error))));
+            return yield* record(resolved ? 'resolved' : 'reopened', note, who, '');
+        });
+        const toComment = Effect.fn('Review.toComment')(function* (id) {
+            const note = yield* notes
+                .toComment(id)
+                .pipe(Effect.catchTag('NotesUnwritable', (error) => Effect.fail(unsaved(error))));
+            return yield* record('converted', note, reviewer, note.summary);
+        });
+        const threads = (after) => Stream.unwrap(Effect.map(Ref.get(events), (all) => {
+            const since = after ?? all.length;
+            const pending = all.filter((event) => event.seq > since);
+            const live = Stream.fromPubSub(threadEvents).pipe(Stream.filter((event) => event.seq > since), Stream.map((event) => [event]));
+            return pending.length > 0 ? Stream.concat(Stream.make(pending), live) : live;
+        }));
         return {
-            snapshots: SubscriptionRef.changes(snapshot),
+            toComment,
+            refresh,
+            startThread,
+            reply,
+            resolve,
+            threads,
+            snapshots,
             file,
             send: (command) => Effect.andThen(PubSub.publish(commands, command), Ref.get(watchers)),
             commands: Stream.unwrap(Effect.as(Ref.update(watchers, (count) => count + 1), Stream.fromPubSub(commands).pipe(Stream.ensuring(Ref.update(watchers, (count) => count - 1))))),
@@ -96,8 +152,10 @@ export class Review extends Context.Service()('sidediff/Review') {
         };
     }));
 }
+const unsavedError = (error) => new NoteUnsaved({ reason: error.message });
 const RpcHandlers = SidediffRpcs.toLayer(Effect.gen(function* () {
     const review = yield* Review;
+    const notes = yield* Notes;
     return SidediffRpcs.of({
         Snapshots: () => review.snapshots,
         File: ({ side, path }) => review.file(side, path),
@@ -107,6 +165,16 @@ const RpcHandlers = SidediffRpcs.toLayer(Effect.gen(function* () {
         View: () => review.view,
         Utter: ({ text, handled }) => review.utter(text, handled),
         Listen: ({ after }) => review.listen(after),
+        StartThread: (input) => review.startThread(input),
+        Reply: ({ noteId, body, author }) => review.reply(noteId, body, author),
+        Resolve: ({ noteId, resolved, author }) => review.resolve(noteId, resolved, author),
+        ToComment: ({ noteId }) => review.toComment(noteId),
+        Threads: ({ after }) => review.threads(after),
+        Refresh: () => review.refresh,
+        ListNotes: () => notes.list,
+        AddNotes: ({ notes: inputs }) => notes.add(inputs).pipe(Effect.mapError(unsavedError)),
+        RemoveNote: ({ id }) => notes.remove(id).pipe(Effect.mapError(unsavedError)),
+        ClearNotes: ({ filePath }) => notes.clear(filePath).pipe(Effect.mapError(unsavedError)),
     });
 }));
 const webRoot = fileURLToPath(new URL('./web', import.meta.url));