Edit a generated note, without losing what the model wrote

app/atomic-write.js

@@ -0,0 +1,26 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Write via a temp file in the SAME directory, then rename. rename(2) is atomic
+// within a filesystem, so a reader either sees the old file or the new one and
+// never a truncated one. The temp name is randomised so two concurrent writers
+// cannot collide, and it is dot-prefixed so a directory listing stays clean.
+function writeFileAtomicSync(targetPath, data) {
+  const dir = path.dirname(targetPath);
+  const base = path.basename(targetPath);
+  const tmpPath = path.join(dir, `.${base}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  try {
+    fs.writeFileSync(tmpPath, data, 'utf8');
+    fs.renameSync(tmpPath, targetPath);
+  } catch (err) {
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch (_) {
+      // The temp file may never have been created. Nothing to clean up.
+    }
+    throw err;
+  }
+}
+
+module.exports = { writeFileAtomicSync };

app/atomic-write.test.js

@@ -0,0 +1,50 @@
+const { test } = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { writeFileAtomicSync } = require('./atomic-write');
+
+function tmpFile(contents) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'atomic-write-'));
+  const file = path.join(dir, 'note.md');
+  fs.writeFileSync(file, contents, 'utf8');
+  return file;
+}
+
+test('writeFileAtomicSync replaces the file contents', () => {
+  const file = tmpFile('old');
+  writeFileAtomicSync(file, 'new');
+  assert.strictEqual(fs.readFileSync(file, 'utf8'), 'new');
+});
+
+test('writeFileAtomicSync creates a file that does not exist yet', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'atomic-write-'));
+  const file = path.join(dir, 'fresh.md');
+  writeFileAtomicSync(file, 'hello');
+  assert.strictEqual(fs.readFileSync(file, 'utf8'), 'hello');
+});
+
+test('a failed write leaves the original intact and removes the temp file', (t) => {
+  const file = tmpFile('original');
+  const dir = path.dirname(file);
+  const before = fs.readdirSync(dir);
+
+  // Force the failure AFTER the temp file has genuinely been written to disk,
+  // by making the rename step itself throw. This is the real window the
+  // atomic-write guarantee protects: the temp file exists, the rename fails,
+  // and the catch block's cleanup must remove it without touching the
+  // original. Using node:test's built-in mock keeps this dependency-free and
+  // restores fs.renameSync automatically once the test ends.
+  t.mock.method(fs, 'renameSync', () => {
+    throw new Error('boom');
+  });
+
+  assert.throws(() => {
+    writeFileAtomicSync(file, 'new');
+  });
+
+  assert.strictEqual(fs.readFileSync(file, 'utf8'), 'original');
+  assert.deepStrictEqual(fs.readdirSync(dir).sort(), before.sort());
+});

app/e2e-mock-ipc.js

@@ -203,6 +203,20 @@ function install({ ipcMain }) {
   // note file; the T1 seeds are consts, so we overlay here instead.
   const meetingOverlay = {};
 
+  // Every update-meeting call, verbatim, so a T1 spec can assert the bridge
+  // was invoked exactly once with exactly the fields it expects (note-edit.t1).
+  // Read via ElectronApplication.evaluate (the main process), not through
+  // window.stenoai in the page: contextBridge's exposed API is read-only from
+  // the renderer's world, so monkey-patching window.stenoai.meetings.update in
+  // page.evaluate silently no-ops instead of recording anything.
+  global.__stenoaiE2eUpdateMeetingCalls = [];
+
+  // Every reprocess-meeting call, same recording trick and the same reason. A
+  // spec that has to prove a rebuild did NOT start cannot assert on the UI
+  // (with the editor open the streaming view is suppressed on purpose), so the
+  // only honest evidence is that the IPC was never reached.
+  global.__stenoaiE2eReprocessCalls = [];
+
   // In-flight soft-deletes (#234), id → the deleted meeting. Mirrors main's
   // pendingDelete map just far enough for undo to hand the row back.
   const pendingDeletes = {};
@@ -462,15 +476,45 @@ function install({ ipcMain }) {
     // permissive default hand the toast an undefined array to map over.
     'list-pending-deletes': async () => ({ success: true, pending: [] }),
 
-    // My notes autosave: persist the overlay so a follow-up get-meeting sees
-    // the edit (mirrors the real update-meeting body-section upsert).
+    // My notes autosave AND the note editor (D9) share this one handler, like
+    // the real update-meeting IPC. `user_notes` overlays the My notes tab; the
+    // four structural note fields overlay the Standard note AND accumulate
+    // into `edited_fields`, mirroring app/note-snapshot.js's markEdited so the
+    // regenerate guard (which reads meeting.edited_fields) sees the same shape
+    // under mock IPC that it would from the real sidecar.
+    // Recorded, then answered exactly the way the permissive unknown-channel
+    // default did (`{ success: true }`, no events): the renderer stays in its
+    // "analyzing" state, which is what the floating-bar T1 already relies on.
+    'reprocess-meeting': async (_event, summaryFile, regenerateTitle, sessionName) => {
+      global.__stenoaiE2eReprocessCalls.push({ summaryFile, regenerateTitle, sessionName });
+      return { success: true };
+    },
+
     'update-meeting': async (_event, summaryFile, patch) => {
+      global.__stenoaiE2eUpdateMeetingCalls.push({ summaryFile, patch });
       if (patch && typeof patch.user_notes === 'string') {
         meetingOverlay[summaryFile] = {
           ...(meetingOverlay[summaryFile] || {}),
           user_notes: patch.user_notes,
         };
       }
+      const changed = [];
+      for (const key of ['summary', 'key_points', 'action_items', 'discussion_areas']) {
+        if (patch && patch[key] !== undefined) {
+          meetingOverlay[summaryFile] = {
+            ...(meetingOverlay[summaryFile] || {}),
+            [key]: patch[key],
+          };
+          changed.push(key);
+        }
+      }
+      if (changed.length) {
+        const existing = meetingOverlay[summaryFile]?.edited_fields || [];
+        meetingOverlay[summaryFile] = {
+          ...(meetingOverlay[summaryFile] || {}),
+          edited_fields: [...new Set([...existing, ...changed])],
+        };
+      }
       return { success: true, message: 'ok' };
     },