gsd-pi 2.66.1-dev.ed243f2 → 2.67.0-dev.43b0159

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -3,9 +3,9 @@
  *
  * Exercises shouldBlockContextWrite() — a pure function that implements:
  *   (a) toolName !== "write" → pass
- *   (b) milestoneId null → pass (not in discussion)
+ *   (b) milestone context must resolve to a verified milestone
  *   (c) path doesn't match /M\d+-CONTEXT\.md$/ → pass
- *   (d) depthVerified → pass
+ *   (d) non-context files → pass
  *   (e) else → block with actionable reason
  */
 
@@ -14,12 +14,12 @@ import assert from 'node:assert/strict';
 import {
   isDepthConfirmationAnswer,
   shouldBlockContextWrite,
-  isDepthVerified,
-  isQueuePhaseActive,
   setQueuePhaseActive,
 } from '../index.ts';
 import {
   markDepthVerified,
+  isMilestoneDepthVerified,
+  shouldBlockContextArtifactSave,
   clearDiscussionFlowState,
   resetWriteGateState,
 } from '../bootstrap/write-gate.ts';
@@ -53,26 +53,27 @@ test('write-gate: blocks CONTEXT.md write during discussion without depth verifi
 // ─── Scenario 3: Allows CONTEXT.md write after depth verification ──
 
 test('write-gate: allows CONTEXT.md write after depth verification', () => {
+  clearDiscussionFlowState();
+  markDepthVerified('M001');
   const result = shouldBlockContextWrite(
     'write',
     '/Users/dev/project/.gsd/milestones/M001/M001-CONTEXT.md',
     'M001',
-    true,
   );
   assert.strictEqual(result.block, false, 'should not block after depth verification');
   assert.strictEqual(result.reason, undefined, 'should have no reason');
+  clearDiscussionFlowState();
 });
 
-// ─── Scenario 4: Allows CONTEXT.md write outside discussion phase (milestoneId null) ──
+// ─── Scenario 4: Ambiguous session context no longer bypasses the gate ──
 
-test('write-gate: allows CONTEXT.md write outside discussion phase', () => {
+test('write-gate: blocks CONTEXT.md write when milestoneId is ambiguous', () => {
   const result = shouldBlockContextWrite(
     'write',
     '.gsd/milestones/M001/M001-CONTEXT.md',
     null,
-    false,
   );
-  assert.strictEqual(result.block, false, 'should not block outside discussion phase');
+  assert.strictEqual(result.block, true, 'should block when milestone context is ambiguous');
 });
 
 // ─── Scenario 5: Allows non-CONTEXT.md writes during discussion ──
@@ -83,7 +84,6 @@ test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
     'write',
     '.gsd/milestones/M001/M001-DISCUSSION.md',
     'M001',
-    false,
   );
   assert.strictEqual(r1.block, false, 'DISCUSSION.md should pass');
 
@@ -92,7 +92,6 @@ test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
     'write',
     '.gsd/milestones/M001/slices/S01/S01-PLAN.md',
     'M001',
-    false,
   );
   assert.strictEqual(r2.block, false, 'slice plan should pass');
 
@@ -101,7 +100,6 @@ test('write-gate: allows non-CONTEXT.md writes during discussion', () => {
     'write',
     'src/index.ts',
     'M001',
-    false,
   );
   assert.strictEqual(r3.block, false, 'regular code file should pass');
 });
@@ -113,7 +111,6 @@ test('write-gate: regex does not match slice context files (S01-CONTEXT.md)', ()
     'write',
     '.gsd/milestones/M001/slices/S01/S01-CONTEXT.md',
     'M001',
-    false,
   );
   assert.strictEqual(result.block, false, 'S01-CONTEXT.md should not be blocked');
 });
@@ -125,7 +122,6 @@ test('write-gate: blocked reason contains depth_verification keyword and anti-by
     'write',
     '.gsd/milestones/M999/M999-CONTEXT.md',
     'M999',
-    false,
   );
   assert.strictEqual(result.block, true);
   assert.ok(result.reason!.includes('depth_verification'), 'reason should mention depth_verification question id');
@@ -141,7 +137,6 @@ test('write-gate: blocks CONTEXT.md write in queue mode without depth verificati
     'write',
     '.gsd/milestones/M001/M001-CONTEXT.md',
     null,   // no milestoneId in queue mode
-    false,  // not depth-verified
     true,   // queue phase active
   );
   assert.strictEqual(result.block, true, 'should block in queue mode without depth verification');
@@ -151,48 +146,228 @@ test('write-gate: blocks CONTEXT.md write in queue mode without depth verificati
 // ─── Scenario 9: Queue mode allows CONTEXT.md write after depth verification ──
 
 test('write-gate: allows CONTEXT.md write in queue mode after depth verification', () => {
+  clearDiscussionFlowState();
+  markDepthVerified('M001');
   const result = shouldBlockContextWrite(
     'write',
     '.gsd/milestones/M001/M001-CONTEXT.md',
     null,   // no milestoneId in queue mode
-    true,   // depth-verified
     true,   // queue phase active
   );
   assert.strictEqual(result.block, false, 'should not block in queue mode after depth verification');
+  clearDiscussionFlowState();
 });
 
-// ─── Scenario 10: markDepthVerified works in queue-only mode (no milestoneId) ──
-// This is the core regression for #1812: in queue mode, the tool_result handler
-// must call markDepthVerified() even when getDiscussionMilestoneId() is null.
+// ─── Scenario 10: depth verification is scoped per milestone, not global ──
 
-test('write-gate: markDepthVerified unblocks queue-mode writes when milestoneId is null', () => {
+test('write-gate: markDepthVerified unlocks only the matching milestone', () => {
   clearDiscussionFlowState();
-  setQueuePhaseActive(true);
+  markDepthVerified('M001');
 
-  // Before marking: should block
-  const blocked = shouldBlockContextWrite(
+  const allowed = shouldBlockContextWrite(
     'write',
     '.gsd/milestones/M001/M001-CONTEXT.md',
     null,
-    isDepthVerified(),
-    isQueuePhaseActive(),
   );
-  assert.strictEqual(blocked.block, true, 'should block before markDepthVerified');
+  assert.strictEqual(allowed.block, false, 'should allow the verified milestone');
 
-  // Simulate what the fixed tool_result handler does
-  markDepthVerified();
-
-  // After marking: should pass
-  const allowed = shouldBlockContextWrite(
+  const blockedOther = shouldBlockContextWrite(
     'write',
-    '.gsd/milestones/M001/M001-CONTEXT.md',
+    '.gsd/milestones/M002/M002-CONTEXT.md',
     null,
-    isDepthVerified(),
-    isQueuePhaseActive(),
   );
-  assert.strictEqual(allowed.block, false, 'should allow after markDepthVerified in queue mode');
+  assert.strictEqual(blockedOther.block, true, 'other milestones should remain blocked');
+  assert.strictEqual(isMilestoneDepthVerified('M001'), true);
+  assert.strictEqual(isMilestoneDepthVerified('M002'), false);
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 11: gsd_summary_save CONTEXT contract is milestone-scoped ──
+
+test('write-gate: gsd_summary_save only blocks final milestone CONTEXT writes', () => {
+  clearDiscussionFlowState();
+
+  assert.strictEqual(
+    shouldBlockContextArtifactSave('CONTEXT-DRAFT', 'M001').block,
+    false,
+    'draft CONTEXT should be allowed',
+  );
+  assert.strictEqual(
+    shouldBlockContextArtifactSave('CONTEXT', 'M001', 'S01').block,
+    false,
+    'slice CONTEXT should be allowed',
+  );
+  assert.strictEqual(
+    shouldBlockContextArtifactSave('CONTEXT', 'M001').block,
+    true,
+    'final milestone CONTEXT should block before verification',
+  );
+
+  markDepthVerified('M001');
+  assert.strictEqual(
+    shouldBlockContextArtifactSave('CONTEXT', 'M001').block,
+    false,
+    'final milestone CONTEXT should pass after verification',
+  );
+
+  clearDiscussionFlowState();
+});
 
+// ═══════════════════════════════════════════════════════════════════════
+// Discussion gate enforcement tests (pending gate mechanism)
+// ═══════════════════════════════════════════════════════════════════════
+
+import {
+  isGateQuestionId,
+  shouldBlockPendingGate,
+  shouldBlockPendingGateBash,
+  setPendingGate,
+  clearPendingGate,
+  getPendingGate,
+} from '../bootstrap/write-gate.ts';
+
+// ─── Scenario 19: isGateQuestionId recognizes all gate patterns ──
+
+test('write-gate: isGateQuestionId recognizes all gate patterns', () => {
+  assert.strictEqual(isGateQuestionId('layer1_scope_gate'), true);
+  assert.strictEqual(isGateQuestionId('layer2_architecture_gate'), true);
+  assert.strictEqual(isGateQuestionId('layer3_error_gate'), true);
+  assert.strictEqual(isGateQuestionId('layer4_quality_gate'), true);
+  assert.strictEqual(isGateQuestionId('depth_verification'), true);
+  assert.strictEqual(isGateQuestionId('depth_verification_M002'), true);
+  assert.strictEqual(isGateQuestionId('my_layer1_scope_gate_question'), true);
+  // Non-gate question IDs
+  assert.strictEqual(isGateQuestionId('project_intent'), false);
+  assert.strictEqual(isGateQuestionId('feature_priority'), false);
+  assert.strictEqual(isGateQuestionId(''), false);
+});
+
+// ─── Scenario 20: setPendingGate / getPendingGate / clearPendingGate lifecycle ──
+
+test('write-gate: pending gate lifecycle (set, get, clear)', () => {
   clearDiscussionFlowState();
+  assert.strictEqual(getPendingGate(), null, 'starts null');
+
+  setPendingGate('layer1_scope_gate');
+  assert.strictEqual(getPendingGate(), 'layer1_scope_gate', 'set correctly');
+
+  clearPendingGate();
+  assert.strictEqual(getPendingGate(), null, 'cleared correctly');
+
+  // clearDiscussionFlowState also clears pending gate
+  setPendingGate('layer2_architecture_gate');
+  clearDiscussionFlowState();
+  assert.strictEqual(getPendingGate(), null, 'clearDiscussionFlowState clears pending gate');
+});
+
+// ─── Scenario 21: shouldBlockPendingGate blocks non-safe tools when gate is pending ──
+
+test('write-gate: shouldBlockPendingGate blocks write/edit during pending gate', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer1_scope_gate');
+
+  // write should be blocked during discussion
+  const writeResult = shouldBlockPendingGate('write', 'M001', false);
+  assert.strictEqual(writeResult.block, true, 'write should be blocked');
+  assert.ok(writeResult.reason!.includes('layer1_scope_gate'), 'reason mentions the gate');
+
+  // edit should be blocked
+  const editResult = shouldBlockPendingGate('edit', 'M001', false);
+  assert.strictEqual(editResult.block, true, 'edit should be blocked');
+
+  // gsd tools should be blocked
+  const gsdResult = shouldBlockPendingGate('gsd_plan_milestone', 'M001', false);
+  assert.strictEqual(gsdResult.block, true, 'gsd tools should be blocked');
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 22: shouldBlockPendingGate allows safe tools when gate is pending ──
+
+test('write-gate: shouldBlockPendingGate allows read-only and ask_user_questions during pending gate', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer1_scope_gate');
+
+  // ask_user_questions is always safe (model needs to re-ask)
+  assert.strictEqual(shouldBlockPendingGate('ask_user_questions', 'M001').block, false);
+  // read-only tools are safe
+  assert.strictEqual(shouldBlockPendingGate('read', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGate('grep', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGate('glob', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGate('ls', 'M001').block, false);
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 23: shouldBlockPendingGate still blocks when the session is ambiguous ──
+
+test('write-gate: shouldBlockPendingGate blocks outside discussion when a gate is pending', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer1_scope_gate');
+
+  // No milestoneId and no queue phase — still block because the gate is pending
+  const result = shouldBlockPendingGate('write', null, false);
+  assert.strictEqual(result.block, true, 'should block even when milestoneId is null');
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 24: shouldBlockPendingGate blocks in queue mode ──
+
+test('write-gate: shouldBlockPendingGate blocks in queue mode when gate is pending', () => {
+  clearDiscussionFlowState();
+  setQueuePhaseActive(true);
+  setPendingGate('depth_verification');
+
+  const result = shouldBlockPendingGate('write', null, true);
+  assert.strictEqual(result.block, true, 'should block in queue mode');
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 25: shouldBlockPendingGateBash allows read-only commands ──
+
+test('write-gate: shouldBlockPendingGateBash allows read-only commands during pending gate', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer2_architecture_gate');
+
+  assert.strictEqual(shouldBlockPendingGateBash('cat file.txt', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGateBash('git log --oneline', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGateBash('grep -r pattern .', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGateBash('ls -la', 'M001').block, false);
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 26: shouldBlockPendingGateBash blocks mutating commands ──
+
+test('write-gate: shouldBlockPendingGateBash blocks mutating commands during pending gate', () => {
+  clearDiscussionFlowState();
+  setPendingGate('layer2_architecture_gate');
+
+  const result = shouldBlockPendingGateBash('npm run build', 'M001');
+  assert.strictEqual(result.block, true, 'mutating bash should be blocked');
+  assert.ok(result.reason!.includes('layer2_architecture_gate'));
+
+  clearDiscussionFlowState();
+});
+
+// ─── Scenario 27: no pending gate means no blocking ──
+
+test('write-gate: no pending gate means no blocking', () => {
+  clearDiscussionFlowState();
+
+  assert.strictEqual(shouldBlockPendingGate('write', 'M001').block, false);
+  assert.strictEqual(shouldBlockPendingGateBash('npm run build', 'M001').block, false);
+});
+
+// ─── Scenario 28: resetWriteGateState clears pending gate ──
+
+test('write-gate: resetWriteGateState clears pending gate', () => {
+  setPendingGate('layer3_error_gate');
+  resetWriteGateState();
+  assert.strictEqual(getPendingGate(), null);
 });
 
 // ─── Standard options fixture used across depth confirmation tests ──

package/src/resources/extensions/gsd/visualizer-overlay.ts

@@ -34,6 +34,24 @@ const TAB_LABELS = [
   "0 Export",
 ];
 
+type TabBarEntry = { label: string; width: number };
+
+function buildTabBarEntries(activeTab: number, filterText: string, capturesPendingCount?: number): TabBarEntry[] {
+  return TAB_LABELS.map((label, i) => {
+    let displayLabel = label;
+    if (i === activeTab && filterText) {
+      displayLabel += " \u2731";
+    }
+    if (i === 8 && capturesPendingCount) {
+      displayLabel += ` (${capturesPendingCount})`;
+    }
+    return {
+      label: displayLabel,
+      width: visibleWidth(displayLabel) + 2,
+    };
+  });
+}
+
 export class GSDVisualizerOverlay {
   private tui: { requestRender: () => void };
   private theme: Theme;
@@ -116,15 +134,14 @@ export class GSDVisualizerOverlay {
   }
 
   handleInput(data: string): void {
+    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+      this.dispose();
+      this.onClose();
+      return;
+    }
+
     // Filter mode input routing
     if (this.filterMode) {
-      if (matchesKey(data, Key.escape)) {
-        this.filterMode = false;
-        this.filterText = "";
-        this.invalidate();
-        this.tui.requestRender();
-        return;
-      }
       if (matchesKey(data, Key.enter)) {
         this.filterMode = false;
         this.invalidate();
@@ -179,8 +196,9 @@ export class GSDVisualizerOverlay {
         // Left click — check if on tab bar row
         if (mouse.y === 2) {
           let xPos = 3;
-          for (let i = 0; i < TAB_LABELS.length; i++) {
-            const tabWidth = TAB_LABELS[i].length + 2;
+          const tabs = buildTabBarEntries(this.activeTab, this.filterText, this.data?.captures?.pendingCount);
+          for (let i = 0; i < tabs.length; i++) {
+            const tabWidth = tabs[i]!.width;
             if (mouse.x >= xPos && mouse.x < xPos + tabWidth) {
               this.activeTab = i;
               this.invalidate();
@@ -194,12 +212,6 @@ export class GSDVisualizerOverlay {
       return;
     }
 
-    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
-      this.dispose();
-      this.onClose();
-      return;
-    }
-
     if (matchesKey(data, Key.shift("tab"))) {
       this.activeTab = (this.activeTab - 1 + TAB_COUNT) % TAB_COUNT;
       this.invalidate();
@@ -442,20 +454,12 @@ export class GSDVisualizerOverlay {
     const content: string[] = [];
 
     // Tab bar
-    const tabs = TAB_LABELS.map((label, i) => {
-      let displayLabel = label;
-      // Show filter indicator on active tab with filter
-      if (i === this.activeTab && this.filterText) {
-        displayLabel += " \u2731";
-      }
-      // Show captures badge
-      if (i === 8 && this.data?.captures?.pendingCount) {
-        displayLabel += ` (${this.data.captures.pendingCount})`;
-      }
+    const tabEntries = buildTabBarEntries(this.activeTab, this.filterText, this.data?.captures?.pendingCount);
+    const tabs = tabEntries.map((entry, i) => {
       if (i === this.activeTab) {
-        return th.fg("accent", `[${displayLabel}]`);
+        return th.fg("accent", `[${entry.label}]`);
       }
-      return th.fg("dim", `[${displayLabel}]`);
+      return th.fg("dim", `[${entry.label}]`);
     });
     content.push(" " + tabs.join(" "));
     content.push("");

package/src/resources/extensions/gsd/workflow-reconcile.ts

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { mkdirSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
-import { readEvents, findForkPoint, appendEvent, getSessionId } from "./workflow-events.js";
+import { readEvents, findForkPoint, getSessionId } from "./workflow-events.js";
 import type { WorkflowEvent } from "./workflow-events.js";
 import {
   transaction,
@@ -329,6 +329,41 @@ export function detectConflicts(
   return conflicts;
 }
 
+function rewriteDivergedEventsForEntity(
+  divergedEvents: WorkflowEvent[],
+  entityType: string,
+  entityId: string,
+  replacementEvents: WorkflowEvent[],
+): WorkflowEvent[] {
+  const rewritten: WorkflowEvent[] = [];
+  let inserted = false;
+
+  for (const event of divergedEvents) {
+    const key = extractEntityKey(event);
+    if (key?.type === entityType && key.id === entityId) {
+      if (!inserted) {
+        rewritten.push(...replacementEvents);
+        inserted = true;
+      }
+      continue;
+    }
+    rewritten.push(event);
+  }
+
+  if (!inserted) {
+    rewritten.push(...replacementEvents);
+  }
+
+  return rewritten;
+}
+
+function writeEventLog(basePath: string, events: WorkflowEvent[]): void {
+  const dir = join(basePath, ".gsd");
+  mkdirSync(dir, { recursive: true });
+  const content = events.map((e) => JSON.stringify(e)).join("\n") + (events.length > 0 ? "\n" : "");
+  atomicWriteSync(join(dir, "event-log.jsonl"), content);
+}
+
 // ─── writeConflictsFile ───────────────────────────────────────────────────────
 
 /**
@@ -575,8 +610,8 @@ function parseEventBlock(block: string): WorkflowEvent[] {
 
 /**
  * Resolve a single conflict by picking one side's events.
- * Replays the picked events through the DB helpers, appends them to the event log,
- * and updates or removes CONFLICTS.md.
+ * Replays the picked events through the DB helpers, rewrites the chosen side's
+ * event log so the conflict is durable, and updates or removes CONFLICTS.md.
  *
  * When the last conflict is resolved, non-conflicting events from both sides
  * are also replayed (they were blocked by the all-or-nothing D-04 rule).
@@ -598,14 +633,30 @@ export function resolveConflict(
   const conflict = conflicts[idx]!;
   const eventsToReplay = pick === "main" ? conflict.mainSideEvents : conflict.worktreeSideEvents;
 
+  const mainLogPath = join(basePath, ".gsd", "event-log.jsonl");
+  const wtLogPath = join(worktreeBasePath, ".gsd", "event-log.jsonl");
+  const mainEvents = readEvents(mainLogPath);
+  const wtEvents = readEvents(wtLogPath);
+  const forkPoint = findForkPoint(mainEvents, wtEvents);
+  const mainBaseEvents = mainEvents.slice(0, forkPoint + 1);
+  const wtBaseEvents = wtEvents.slice(0, forkPoint + 1);
+  const mainDiverged = mainEvents.slice(forkPoint + 1);
+  const wtDiverged = wtEvents.slice(forkPoint + 1);
+
+  const rewrittenTargetEvents = pick === "main"
+    ? rewriteDivergedEventsForEntity(wtDiverged, entityType, entityId, eventsToReplay)
+    : rewriteDivergedEventsForEntity(mainDiverged, entityType, entityId, eventsToReplay);
+
+  const targetBasePath = pick === "main" ? worktreeBasePath : basePath;
+  const targetBaseEvents = pick === "main" ? wtBaseEvents : mainBaseEvents;
+  writeEventLog(targetBasePath, targetBaseEvents.concat(rewrittenTargetEvents));
+
   // Replay resolved events through the DB (updates DB state)
   openDatabase(join(basePath, ".gsd", "gsd.db"));
   replayEvents(eventsToReplay);
-
-  // Append resolved events to the event log
-  for (const event of eventsToReplay) {
-    appendEvent(basePath, { cmd: event.cmd, params: event.params, ts: event.ts, actor: event.actor });
-  }
+  invalidateStateCache();
+  clearPathCache();
+  clearParseCache();
 
   // Remove resolved conflict from list
   conflicts.splice(idx, 1);

package/src/resources/extensions/remote-questions/manager.ts

@@ -24,6 +24,15 @@ interface QuestionInput {
   allowMultiple?: boolean;
 }
 
+/**
+ * Check whether a remote channel is configured without triggering any
+ * side effects (no HTTP requests, no prompt records). Used by the race
+ * logic to decide routing before committing to a remote dispatch.
+ */
+export function isRemoteConfigured(): boolean {
+  return resolveRemoteConfig() !== null;
+}
+
 export async function tryRemoteQuestions(
   questions: QuestionInput[],
   signal?: AbortSignal,

package/src/resources/extensions/shared/interview-ui.ts

@@ -80,6 +80,12 @@ export interface InterviewRoundOptions {
 	 * Label for the Esc-confirm overlay header. Defaults to "End interview?".
 	 */
 	exitHeadline?: string;
+	/**
+	 * Optional AbortSignal to cancel the interview externally (e.g. when racing
+	 * against a remote question channel). When aborted, the TUI closes and the
+	 * promise resolves with an empty answers object.
+	 */
+	signal?: AbortSignal;
 	/**
 	 * Text for the "exit" hint shown in the review screen footer and exit confirm overlay.
 	 * Defaults to "end interview".
@@ -207,6 +213,13 @@ export async function showInterviewRound(
 		let exitCursor = 0; // 0 = keep going (default), 1 = end interview
 		let cachedLines: string[] | undefined;
 
+		// External cancellation (e.g. remote channel won the race)
+		if (opts.signal) {
+			const onAbort = () => done({ endInterview: false, answers: {} });
+			if (opts.signal.aborted) { onAbort(); }
+			else { opts.signal.addEventListener("abort", onAbort, { once: true }); }
+		}
+
 		// Editor is created once; editorTheme comes from the design system
 		const editorRef = { current: null as Editor | null };