pi-blackhole 0.4.2 → 0.4.3

package/src/commands/pi-vcc.ts

@@ -3,171 +3,221 @@
  *
  * Upstream: https://github.com/sting8k/pi-vcc (src/commands/pi-vcc.ts)
  * Modified by pi-vcc-om:
- * - Flushes pending OM state (observations/reflections/dropped) when noAutoCompact is active
+ * - Flushes pending OM state (observations/reflections/dropped) when manual mode is active
  *   before triggering compaction, so the compaction summary includes all accumulated memory.
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { Runtime } from "../om/runtime.js";
-import { PI_VCC_COMPACT_INSTRUCTION, notifyMigrationReminder, formatCompactionStats } from "../hooks/before-compact";
-import { saveUnifiedConfig, configPath } from "../core/unified-config.js";
-import { readPendingState, clearPendingState, hasPendingData } from "../om/pending.js";
-import { createConfigureOverlay } from "../om/configure-overlay.js";
 import {
-	OM_OBSERVATIONS_DROPPED,
-	OM_OBSERVATIONS_RECORDED,
-	OM_REFLECTIONS_RECORDED,
+  PI_VCC_COMPACT_INSTRUCTION,
+  notifyMigrationReminder,
+  formatCompactionStats,
+} from "../hooks/before-compact";
+import {
+  readPendingState,
+  clearPendingState,
+  hasPendingData,
+} from "../om/pending.js";
+import {
+  OM_OBSERVATIONS_DROPPED,
+  OM_OBSERVATIONS_RECORDED,
+  OM_REFLECTIONS_RECORDED,
 } from "../om/ledger/index.js";
 import { handleCleanup } from "./cleanup.js";
+import {
+  openBlackholeSettings,
+  config,
+  GLOBAL_CONFIG_DIR,
+} from "../pi-base/blackhole-settings.js";
 
 export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
-	const prefixMatch = (value: string, prefix: string): boolean => {
-		return value.toLowerCase().startsWith(prefix.toLowerCase());
-	};
-
-	pi.registerCommand("blackhole", {
-		description:
-			"Compact conversation — structured summary (with observational memory when enabled). " +
-			"Subcommands: [configure] settings overlay, [cleanup] remove orphaned files, " +
-			"[om-off] / [om-on] disable / re-enable memory.",
-		getArgumentCompletions: (prefix: string) => {
-			const subcommands = [
-				{ value: "configure", label: "Open configuration overlay to edit settings [configure]" },
-				{ value: "cleanup", label: "Find and remove orphaned pending files [cleanup]" },
-				{ value: "om-off", label: "Disable observational memory [om-off]" },
-				{ value: "om-on", label: "Enable observational memory [om-on]" },
-			];
-			if (!prefix) return subcommands;
-			return subcommands.filter((s) => prefixMatch(s.value, prefix));
-		},
-		handler: async (args, ctx) => {
-			const sessionId = ctx.sessionManager.getSessionId();
+  const prefixMatch = (value: string, prefix: string): boolean => {
+    return value.toLowerCase().startsWith(prefix.toLowerCase());
+  };
 
-			// Handle subcommands
-			const trimmed = (typeof args === "string" ? args : "").trim();
-			if (trimmed === "configure") {
-				// Open the config overlay
-				const result = await ctx.ui.custom<{ saved: boolean; path: string; error?: string } | undefined>(
-					(tui, theme, _kb, done) => createConfigureOverlay(configPath(), theme, tui, done),
-					{ overlay: true },
-				);
-				if (result) {
-					if (result.error) {
-						ctx.ui.notify(result.error, "warning");
-					} else if (result.saved) {
-						runtime.reloadConfig(ctx.cwd, (msg) => ctx.ui?.notify?.(msg, "warning"));
-						ctx.ui.notify("Configuration saved.", "info");
-					} else {
-						ctx.ui.notify("Failed to save configuration — the config file may be read-only (e.g., managed by Nix).", "warning");
-					}
-				}
-				return;
-			}
-			if (trimmed === "cleanup") {
-				await handleCleanup(ctx);
-				return;
-			}
-			if (trimmed === "om-off") {
-				const saved = saveUnifiedConfig({ memory: false });
-				runtime.config.memory = false;
-				if (saved) {
-					ctx.ui.notify("Observational memory disabled. Use /blackhole om-on to re-enable.", "info");
-				} else {
-					ctx.ui.notify(
-						"Failed to save config — the config file may be read-only (e.g., managed by Nix). " +
-						"Runtime state updated for this session only.",
-						"warning",
-					);
-				}
-				return;
-			}
-			if (trimmed === "om-on") {
-				const saved = saveUnifiedConfig({ memory: true });
-				runtime.config.memory = true;
-				if (saved) {
-					ctx.ui.notify("Observational memory enabled.", "info");
-				} else {
-					ctx.ui.notify(
-						"Failed to save config — the config file may be read-only (e.g., managed by Nix). " +
-						"Runtime state updated for this session only.",
-						"warning",
-					);
-				}
-				return;
-			}
+  pi.registerCommand("blackhole", {
+    description:
+      "Manual compact with structural summary. Subcommands: [settings] config overlay, " +
+      "[cleanup] remove orphaned files, [om-off]/[om-on] disable/enable observational memory.",
+    getArgumentCompletions: (prefix: string) => {
+      const subcommands = [
+        {
+          value: "settings",
+          label: "Open configuration overlay [settings]",
+        },
+        {
+          value: "cleanup",
+          label: "Remove orphaned pending files [cleanup]",
+        },
+        { value: "om-off", label: "Disable observational memory [om-off]" },
+        { value: "om-on", label: "Enable observational memory [om-on]" },
+      ];
+      if (!prefix) return subcommands;
+      // "configure" is an accepted alias for "settings" (routed by the
+      // handler); surface the settings entry when the user types either.
+      return subcommands.filter(
+        (s) =>
+          prefixMatch(s.value, prefix) ||
+          (s.value === "settings" && prefixMatch("configure", prefix)),
+      );
+    },
+    handler: async (args, ctx) => {
+      const sessionId = ctx.sessionManager.getSessionId();
 
-			// Warn if input starts with a known subcommand but isn't an exact match.
-			// Prevents "/blackhole configure foo" from silently becoming a follow-up.
-			const SUBCOMMAND_NAMES = ["configure", "cleanup", "om-off", "om-on"];
-			const nearMiss = SUBCOMMAND_NAMES.find(
-				name => trimmed.toLowerCase().startsWith(name.toLowerCase()) && trimmed.length > name.length
-			);
-			if (nearMiss) {
-				ctx.ui.notify(`/blackhole ${nearMiss} accepts no arguments. Did you mean \"/blackhole ${nearMiss}\"?`, "warning");
-				return;
-			}
+      // Handle subcommands
+      const trimmed = (typeof args === "string" ? args : "").trim();
+      if (trimmed === "configure" || trimmed === "settings") {
+        // Open the config overlay ("configure" kept as a hidden alias)
+        await openBlackholeSettings(ctx);
+        return;
+      }
+      if (trimmed === "cleanup") {
+        await handleCleanup(ctx);
+        return;
+      }
+      if (trimmed === "om-off") {
+        try {
+          config.save(
+            { ...config.load(ctx.cwd, GLOBAL_CONFIG_DIR), memory: false },
+            "global",
+            ctx.cwd,
+            GLOBAL_CONFIG_DIR,
+          );
+          runtime.config = config.loadWithWarnings(
+            ctx.cwd,
+            GLOBAL_CONFIG_DIR,
+          ).config;
+          ctx.ui.notify(
+            "Observational memory disabled. Use /blackhole om-on to re-enable.",
+            "info",
+          );
+        } catch {
+          ctx.ui.notify(
+            "Failed to save config — the config file may be read-only (e.g., managed by Nix). " +
+              "Runtime state updated for this session only.",
+            "warning",
+          );
+        }
+        return;
+      }
+      if (trimmed === "om-on") {
+        try {
+          config.save(
+            { ...config.load(ctx.cwd, GLOBAL_CONFIG_DIR), memory: true },
+            "global",
+            ctx.cwd,
+            GLOBAL_CONFIG_DIR,
+          );
+          runtime.config = config.loadWithWarnings(
+            ctx.cwd,
+            GLOBAL_CONFIG_DIR,
+          ).config;
+          ctx.ui.notify("Observational memory enabled.", "info");
+        } catch {
+          ctx.ui.notify(
+            "Failed to save config — the config file may be read-only (e.g., managed by Nix). " +
+              "Runtime state updated for this session only.",
+            "warning",
+          );
+        }
+        return;
+      } // Warn if input starts with a known subcommand but isn't an exact match.
+      // Prevents "/blackhole configure foo" from silently becoming a follow-up.
+      const SUBCOMMAND_NAMES = [
+        "configure",
+        "settings",
+        "cleanup",
+        "om-off",
+        "om-on",
+      ];
+      const nearMiss = SUBCOMMAND_NAMES.find(
+        (name) =>
+          trimmed.toLowerCase().startsWith(name.toLowerCase()) &&
+          trimmed.length > name.length,
+      );
+      if (nearMiss) {
+        ctx.ui.notify(
+          `/blackhole ${nearMiss} accepts no arguments. Did you mean \"/blackhole ${nearMiss}\"?`,
+          "warning",
+        );
+        return;
+      }
 
-			// Extract follow-up prompt: everything after the subcommand check
-			// that isn't a known subcommand is treated as follow-up text.
-			const followUpPrompt = trimmed ? trimmed : null;
+      // Extract follow-up prompt: everything after the subcommand check
+      // that isn't a known subcommand is treated as follow-up text.
+      const followUpPrompt = trimmed ? trimmed : null;
 
-			// If compaction is manual (or legacy noAutoCompact): flush pending OM entries
-			// into the branch before compacting so the summary includes accumulated memory.
-			if (runtime.config.compaction === "manual" && hasPendingData(sessionId)) {
-				const pending = readPendingState(sessionId);
-				// Write all accumulated observation batches (or latest single batch
-				// as fallback for legacy pending.json without batch arrays).
-				const obsBatches = pending.observationBatches?.length
-					? pending.observationBatches
-					: (pending.observation ? [pending.observation] : []);
-				for (const batch of obsBatches) {
-					pi.appendEntry(OM_OBSERVATIONS_RECORDED, batch.data);
-				}
-				// Write all accumulated reflection batches (or latest single batch
-				// as fallback for legacy pending.json without batch arrays).
-				const reflBatches = pending.reflectionBatches?.length
-					? pending.reflectionBatches
-					: (pending.reflection ? [pending.reflection] : []);
-				for (const batch of reflBatches) {
-					pi.appendEntry(OM_REFLECTIONS_RECORDED, batch.data);
-				}
-				// Write all accumulated dropper batches (or latest single batch
-				// as fallback for legacy pending.json without batch arrays).
-				const dropBatches = pending.droppedBatches?.length
-					? pending.droppedBatches
-					: (pending.dropped ? [pending.dropped] : []);
-				for (const batch of dropBatches) {
-					pi.appendEntry(OM_OBSERVATIONS_DROPPED, batch.data);
-				}
-				clearPendingState(sessionId);
-				ctx.ui.notify("Observational memory: pending entries flushed", "info");
-			}
+      // If compaction is manual (or legacy noAutoCompact): flush pending OM entries
+      // into the branch before compacting so the summary includes accumulated memory.
+      if (runtime.config.compaction === "manual" && hasPendingData(sessionId)) {
+        const pending = readPendingState(sessionId);
+        // Write all accumulated observation batches (or latest single batch
+        // as fallback for legacy pending.json without batch arrays).
+        const obsBatches = pending.observationBatches?.length
+          ? pending.observationBatches
+          : pending.observation
+            ? [pending.observation]
+            : [];
+        for (const batch of obsBatches) {
+          pi.appendEntry(OM_OBSERVATIONS_RECORDED, batch.data);
+        }
+        // Write all accumulated reflection batches (or latest single batch
+        // as fallback for legacy pending.json without batch arrays).
+        const reflBatches = pending.reflectionBatches?.length
+          ? pending.reflectionBatches
+          : pending.reflection
+            ? [pending.reflection]
+            : [];
+        for (const batch of reflBatches) {
+          pi.appendEntry(OM_REFLECTIONS_RECORDED, batch.data);
+        }
+        // Write all accumulated dropper batches (or latest single batch
+        // as fallback for legacy pending.json without batch arrays).
+        const dropBatches = pending.droppedBatches?.length
+          ? pending.droppedBatches
+          : pending.dropped
+            ? [pending.dropped]
+            : [];
+        for (const batch of dropBatches) {
+          pi.appendEntry(OM_OBSERVATIONS_DROPPED, batch.data);
+        }
+        clearPendingState(sessionId);
+        ctx.ui.notify("Observational memory: pending entries flushed", "info");
+      }
 
-			ctx.compact({
-				customInstructions: PI_VCC_COMPACT_INSTRUCTION,
-				onComplete: () => {
-					const stats = runtime.compactionStats;
-					if (stats) {
-						ctx.ui.notify(formatCompactionStats(stats), "info");
-					} else {
-						ctx.ui.notify("Compacted with blackhole", "info");
-					}
-					notifyMigrationReminder(sessionId, (msg, level) => ctx.ui.notify(msg, level as any));
+      ctx.compact({
+        customInstructions: PI_VCC_COMPACT_INSTRUCTION,
+        onComplete: () => {
+          const stats = runtime.compactionStats;
+          if (stats) {
+            ctx.ui.notify(formatCompactionStats(stats), "info");
+          } else {
+            ctx.ui.notify("Compacted with blackhole", "info");
+          }
+          notifyMigrationReminder(sessionId, (msg, level) =>
+            ctx.ui.notify(msg, level as any),
+          );
 
-					// Fire follow-up prompt after compaction completes
-					if (followUpPrompt) {
-						try {
-							void Promise.resolve(pi.sendUserMessage(followUpPrompt)).catch(() => {});
-						} catch {}
-					}
-				},
-				onError: (err) => {
-					if (err.message === "Compaction cancelled" || err.message === "Already compacted") {
-						ctx.ui.notify("Nothing to compact", "warning");
-					} else {
-						ctx.ui.notify(`Compaction failed: ${err.message}`, "error");
-					}
-				},
-			});
-		},
-	});
+          // Fire follow-up prompt after compaction completes
+          if (followUpPrompt) {
+            try {
+              void Promise.resolve(pi.sendUserMessage(followUpPrompt)).catch(
+                () => {},
+              );
+            } catch {}
+          }
+        },
+        onError: (err) => {
+          if (
+            err.message === "Compaction cancelled" ||
+            err.message === "Already compacted"
+          ) {
+            ctx.ui.notify("Nothing to compact", "warning");
+          } else {
+            ctx.ui.notify(`Compaction failed: ${err.message}`, "error");
+          }
+        },
+      });
+    },
+  });
 };

package/src/commands/vcc-recall.ts

@@ -7,13 +7,16 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadAllMessages } from "../core/load-messages.js";
 import { searchEntries, getTouchedFiles } from "../core/search-entries.js";
-import { formatRecallOutput, formatTouchedOutput } from "../core/format-recall.js";
+import {
+  formatRecallOutput,
+  formatTouchedOutput,
+} from "../core/format-recall.js";
 import { getActiveLineageEntryIds } from "../core/lineage.js";
 import { parseRecallScope } from "../core/recall-scope.js";
 import {
-	findObservationsForEntryIds,
-	findReflectionsForEntryIds,
-	formatRelatedObservations,
+  findObservationsForEntryIds,
+  findReflectionsForEntryIds,
+  formatRelatedObservations,
 } from "../om/reverse-recall.js";
 import type { Entry } from "../om/ledger/recall.js";
 
@@ -21,106 +24,134 @@ const PAGE_SIZE = 5;
 const DEFAULT_RECENT = 25;
 
 async function augmentWithObservations(
-	output: string,
-	rendered: { id: string }[],
-	ctx: any,
+  output: string,
+  rendered: { id: string }[],
+  ctx: any,
 ): Promise<string> {
-	const ids = rendered.map((e) => e.id).filter(Boolean);
-	if (ids.length === 0) return output;
-	try {
-		const branchEntries = ctx.sessionManager.getBranch() as Entry[];
-		const obs = findObservationsForEntryIds(branchEntries, ids);
-		const refs = findReflectionsForEntryIds(branchEntries, ids);
-		if (obs.length > 0 || refs.length > 0) {
-			return output + "\n\n" + formatRelatedObservations(obs, refs);
-		}
-	} catch { /* branch may not be available */ }
-	return output;
+  const ids = rendered.map((e) => e.id).filter(Boolean);
+  if (ids.length === 0) return output;
+  try {
+    const branchEntries = ctx.sessionManager.getBranch() as Entry[];
+    const obs = findObservationsForEntryIds(branchEntries, ids);
+    const refs = findReflectionsForEntryIds(branchEntries, ids);
+    if (obs.length > 0 || refs.length > 0) {
+      return output + "\n\n" + formatRelatedObservations(obs, refs);
+    }
+  } catch {
+    /* branch may not be available */
+  }
+  return output;
 }
 
 export const registerVccRecallCommand = (pi: ExtensionAPI) => {
-	pi.registerCommand("blackhole-recall", {
-		description:
-			"Search session history. Defaults to active lineage. Usage: /blackhole-recall <query> [page:N] [scope:all] [mode:file|touched]",
-		handler: async (args: string, ctx) => {
-			const sessionFile = ctx.sessionManager.getSessionFile();
-			if (!sessionFile) {
-				ctx.ui.notify("No session file available.", "error");
-				return;
-			}
+  pi.registerCommand("blackhole-recall", {
+    description:
+      "Search session history. Defaults to active lineage. Usage: /blackhole-recall <query> [page:N] [scope:all] [mode:file|touched]",
+    handler: async (args: string, ctx) => {
+      const sessionFile = ctx.sessionManager.getSessionFile();
+      if (!sessionFile) {
+        ctx.ui.notify("No session file available.", "error");
+        return;
+      }
 
-			const raw = args.trim();
-			const parsed = parseRecallScope(raw);
-			const lineageEntryIds =
-				parsed.scope === "lineage"
-					? getActiveLineageEntryIds(ctx.sessionManager)
-					: undefined;
-			const mode = parsed.mode;
+      const raw = args.trim();
+      const parsed = parseRecallScope(raw);
+      const lineageEntryIds =
+        parsed.scope === "lineage"
+          ? getActiveLineageEntryIds(ctx.sessionManager)
+          : undefined;
+      const mode = parsed.mode;
 
-			if (mode === "touched") {
-				const pageMatch = raw.match(/\bpage:(\d+)\b/i);
-				const page = pageMatch ? Math.max(1, parseInt(pageMatch[1], 10)) : 1;
-				const { rendered, rawMessages } = loadAllMessages(sessionFile, false, lineageEntryIds);
-				const touched = getTouchedFiles(rawMessages, rendered);
-				const text = formatTouchedOutput(touched, page);
-				pi.sendMessage(
-					{ customType: "blackhole-recall", content: text, display: true },
-					{ triggerTurn: true },
-				);
-				return;
-			}
+      if (mode === "touched") {
+        const pageMatch = raw.match(/\bpage:(\d+)\b/i);
+        const page = pageMatch ? Math.max(1, parseInt(pageMatch[1], 10)) : 1;
+        const { rendered, rawMessages } = loadAllMessages(
+          sessionFile,
+          false,
+          lineageEntryIds,
+        );
+        const touched = getTouchedFiles(rawMessages, rendered);
+        const text = formatTouchedOutput(touched, page);
+        pi.sendMessage(
+          { customType: "blackhole-recall", content: text, display: true },
+          { triggerTurn: true },
+        );
+        return;
+      }
 
-			if (!parsed.text) {
-				// No query: show recent entries
-				const { rendered } = loadAllMessages(sessionFile, false, lineageEntryIds);
-				const recent = rendered.slice(-DEFAULT_RECENT);
-				const base = (parsed.scope === "all" ? "Scope: all\n\n" : "") + formatRecallOutput(recent);
-				const output = await augmentWithObservations(base, recent, ctx);
-				pi.sendMessage(
-					{ customType: "blackhole-recall", content: output, display: true },
-					{ triggerTurn: true },
-				);
-				return;
-			}
+      if (!parsed.text) {
+        // No query: show recent entries
+        const { rendered } = loadAllMessages(
+          sessionFile,
+          false,
+          lineageEntryIds,
+        );
+        const recent = rendered.slice(-DEFAULT_RECENT);
+        const base =
+          (parsed.scope === "all" ? "Scope: all\n\n" : "") +
+          formatRecallOutput(recent);
+        const output = await augmentWithObservations(base, recent, ctx);
+        pi.sendMessage(
+          { customType: "blackhole-recall", content: output, display: true },
+          { triggerTurn: true },
+        );
+        return;
+      }
 
-			// Parse page:N from args
-			const pageMatch = parsed.text.match(/\bpage:(\d+)\b/i);
-			const page = pageMatch ? Math.max(1, parseInt(pageMatch[1], 10)) : 1;
-			const query = parsed.text.replace(/\bpage:\d+\b/i, "").trim();
+      // Parse page:N from args
+      const pageMatch = parsed.text.match(/\bpage:(\d+)\b/i);
+      const page = pageMatch ? Math.max(1, parseInt(pageMatch[1], 10)) : 1;
+      const query = parsed.text.replace(/\bpage:\d+\b/i, "").trim();
 
-			if (!query) {
-				const { rendered } = loadAllMessages(sessionFile, false, lineageEntryIds);
-				const recent = rendered.slice(-DEFAULT_RECENT);
-				const base = (parsed.scope === "all" ? "Scope: all\n\n" : "") + formatRecallOutput(recent);
-				const output = await augmentWithObservations(base, recent, ctx);
-				pi.sendMessage(
-					{ customType: "blackhole-recall", content: output, display: true },
-					{ triggerTurn: true },
-				);
-				return;
-			}
+      if (!query) {
+        const { rendered } = loadAllMessages(
+          sessionFile,
+          false,
+          lineageEntryIds,
+        );
+        const recent = rendered.slice(-DEFAULT_RECENT);
+        const base =
+          (parsed.scope === "all" ? "Scope: all\n\n" : "") +
+          formatRecallOutput(recent);
+        const output = await augmentWithObservations(base, recent, ctx);
+        pi.sendMessage(
+          { customType: "blackhole-recall", content: output, display: true },
+          { triggerTurn: true },
+        );
+        return;
+      }
 
-			const { rendered, rawMessages } = loadAllMessages(sessionFile, false, lineageEntryIds);
-			const allResults = searchEntries(rendered, rawMessages, query, undefined, mode);
+      const { rendered, rawMessages } = loadAllMessages(
+        sessionFile,
+        false,
+        lineageEntryIds,
+      );
+      const allResults = searchEntries(
+        rendered,
+        rawMessages,
+        query,
+        undefined,
+        mode,
+      );
 
-			const start = (page - 1) * PAGE_SIZE;
-			const pageResults = allResults.slice(start, start + PAGE_SIZE);
-			const totalPages = Math.ceil(allResults.length / PAGE_SIZE);
-			const scopeSuffix = parsed.scope === "all" ? " (scope: all)" : "";
-			const header =
-				totalPages > 1
-					? `Page ${page}/${totalPages} (${allResults.length} total matches${scopeSuffix})`
-					: `${allResults.length} matches${scopeSuffix}`;
-			const footer =
-				page < totalPages
-					? `\n--- /blackhole-recall ${query}${parsed.scope === "all" ? " scope:all" : ""} page:${page + 1} ---`
-					: "";
-			const base = formatRecallOutput(pageResults, query, header) + footer;
-			const output = await augmentWithObservations(base, pageResults, ctx);
-			pi.sendMessage(
-				{ customType: "blackhole-recall", content: output, display: true },
-				{ triggerTurn: true },
-			);
-		},
-	});
+      const start = (page - 1) * PAGE_SIZE;
+      const pageResults = allResults.slice(start, start + PAGE_SIZE);
+      const totalPages = Math.ceil(allResults.length / PAGE_SIZE);
+      const scopeSuffix = parsed.scope === "all" ? " (scope: all)" : "";
+      const header =
+        totalPages > 1
+          ? `Page ${page}/${totalPages} (${allResults.length} total matches${scopeSuffix})`
+          : `${allResults.length} matches${scopeSuffix}`;
+      const footer =
+        page < totalPages
+          ? `\n--- /blackhole-recall ${query}${parsed.scope === "all" ? " scope:all" : ""} page:${page + 1} ---`
+          : "";
+      const base = formatRecallOutput(pageResults, query, header) + footer;
+      const output = await augmentWithObservations(base, pageResults, ctx);
+      pi.sendMessage(
+        { customType: "blackhole-recall", content: output, display: true },
+        { triggerTurn: true },
+      );
+    },
+  });
 };