gsd-pi 2.26.0 → 2.27.0

package/dist/resources/extensions/bg-shell/types.ts

@@ -53,6 +53,10 @@ export interface BgProcess {
 	label: string;
 	command: string;
 	cwd: string;
+	/** Session file that created this process (used for per-session cleanup) */
+	ownerSessionFile: string | null;
+	/** Whether this process should survive a new-session boundary */
+	persistAcrossSessions: boolean;
 	startedAt: number;
 	proc: import("node:child_process").ChildProcess;
 	/** Unified chronologically-interleaved output buffer */
@@ -103,7 +107,17 @@ export interface BgProcess {
 	/** Restart count */
 	restartCount: number;
 	/** Original start config for restart */
-	startConfig: { command: string; cwd: string; label: string; processType: ProcessType; readyPattern: string | null; readyPort: number | null; group: string | null };
+	startConfig: {
+		command: string;
+		cwd: string;
+		label: string;
+		processType: ProcessType;
+		ownerSessionFile: string | null;
+		persistAcrossSessions: boolean;
+		readyPattern: string | null;
+		readyPort: number | null;
+		group: string | null;
+	};
 }
 
 export interface BgProcessInfo {
@@ -111,6 +125,8 @@ export interface BgProcessInfo {
 	label: string;
 	command: string;
 	cwd: string;
+	ownerSessionFile: string | null;
+	persistAcrossSessions: boolean;
 	startedAt: number;
 	alive: boolean;
 	exitCode: number | null;
@@ -133,6 +149,8 @@ export interface BgProcessInfo {
 export interface StartOptions {
 	command: string;
 	cwd: string;
+	ownerSessionFile?: string | null;
+	persistAcrossSessions?: boolean;
 	label?: string;
 	type?: ProcessType;
 	readyPattern?: string;
@@ -154,6 +172,8 @@ export interface ProcessManifest {
 	label: string;
 	command: string;
 	cwd: string;
+	ownerSessionFile: string | null;
+	persistAcrossSessions: boolean;
 	startedAt: number;
 	processType: ProcessType;
 	group: string | null;

package/dist/resources/extensions/gsd/auto/session.ts

@@ -0,0 +1,224 @@
+/**
+ * AutoSession — encapsulates all mutable auto-mode state into a single instance.
+ *
+ * Replaces ~40 module-level variables scattered across auto.ts with typed
+ * properties on a class instance. Benefits:
+ *
+ * - reset() clears everything in one call (was 25+ manual resets in stopAuto)
+ * - toJSON() provides diagnostic snapshots
+ * - grep `s.` shows every state access
+ * - Constructable for testing
+ */
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import type { GitServiceImpl } from "../git-service.js";
+import type { CaptureEntry } from "../captures.js";
+import type { BudgetAlertLevel } from "../auto-budget.js";
+
+// ─── Exported Types ──────────────────────────────────────────────────────────
+
+export interface CompletedUnit {
+  type: string;
+  id: string;
+  startedAt: number;
+  finishedAt: number;
+}
+
+export interface CurrentUnit {
+  type: string;
+  id: string;
+  startedAt: number;
+}
+
+export interface UnitRouting {
+  tier: string;
+  modelDowngraded: boolean;
+}
+
+export interface StartModel {
+  provider: string;
+  id: string;
+}
+
+export interface PendingVerificationRetry {
+  unitId: string;
+  failureContext: string;
+  attempt: number;
+}
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+export const MAX_UNIT_DISPATCHES = 3;
+export const STUB_RECOVERY_THRESHOLD = 2;
+export const MAX_LIFETIME_DISPATCHES = 6;
+export const MAX_CONSECUTIVE_SKIPS = 3;
+export const DISPATCH_GAP_TIMEOUT_MS = 5_000;
+export const MAX_SKIP_DEPTH = 20;
+
+// ─── AutoSession ─────────────────────────────────────────────────────────────
+
+export class AutoSession {
+  // ── Lifecycle ────────────────────────────────────────────────────────────
+  active = false;
+  paused = false;
+  stepMode = false;
+  verbose = false;
+  cmdCtx: ExtensionCommandContext | null = null;
+
+  // ── Paths ────────────────────────────────────────────────────────────────
+  basePath = "";
+  originalBasePath = "";
+  gitService: GitServiceImpl | null = null;
+
+  // ── Dispatch counters ────────────────────────────────────────────────────
+  readonly unitDispatchCount = new Map<string, number>();
+  readonly unitLifetimeDispatches = new Map<string, number>();
+  readonly unitRecoveryCount = new Map<string, number>();
+  readonly unitConsecutiveSkips = new Map<string, number>();
+  readonly completedKeySet = new Set<string>();
+
+  // ── Timers ───────────────────────────────────────────────────────────────
+  unitTimeoutHandle: ReturnType<typeof setTimeout> | null = null;
+  wrapupWarningHandle: ReturnType<typeof setTimeout> | null = null;
+  idleWatchdogHandle: ReturnType<typeof setInterval> | null = null;
+  continueHereHandle: ReturnType<typeof setInterval> | null = null;
+  dispatchGapHandle: ReturnType<typeof setTimeout> | null = null;
+
+  // ── Current unit ─────────────────────────────────────────────────────────
+  currentUnit: CurrentUnit | null = null;
+  currentUnitRouting: UnitRouting | null = null;
+  completedUnits: CompletedUnit[] = [];
+  currentMilestoneId: string | null = null;
+
+  // ── Model state ──────────────────────────────────────────────────────────
+  autoModeStartModel: StartModel | null = null;
+  originalModelId: string | null = null;
+  originalModelProvider: string | null = null;
+  lastBudgetAlertLevel: BudgetAlertLevel = 0;
+
+  // ── Recovery ─────────────────────────────────────────────────────────────
+  pendingCrashRecovery: string | null = null;
+  pendingVerificationRetry: PendingVerificationRetry | null = null;
+  readonly verificationRetryCount = new Map<string, number>();
+  pausedSessionFile: string | null = null;
+  resourceVersionOnStart: string | null = null;
+  lastStateRebuildAt = 0;
+
+  // ── Guards ───────────────────────────────────────────────────────────────
+  handlingAgentEnd = false;
+  dispatching = false;
+  skipDepth = 0;
+  readonly recentlyEvictedKeys = new Set<string>();
+
+  // ── Metrics ──────────────────────────────────────────────────────────────
+  autoStartTime = 0;
+  lastPromptCharCount: number | undefined;
+  lastBaselineCharCount: number | undefined;
+  pendingQuickTasks: CaptureEntry[] = [];
+
+  // ── Signal handler ───────────────────────────────────────────────────────
+  sigtermHandler: (() => void) | null = null;
+
+  // ── Methods ──────────────────────────────────────────────────────────────
+
+  clearTimers(): void {
+    if (this.unitTimeoutHandle) { clearTimeout(this.unitTimeoutHandle); this.unitTimeoutHandle = null; }
+    if (this.wrapupWarningHandle) { clearTimeout(this.wrapupWarningHandle); this.wrapupWarningHandle = null; }
+    if (this.idleWatchdogHandle) { clearInterval(this.idleWatchdogHandle); this.idleWatchdogHandle = null; }
+    if (this.continueHereHandle) { clearInterval(this.continueHereHandle); this.continueHereHandle = null; }
+    if (this.dispatchGapHandle) { clearTimeout(this.dispatchGapHandle); this.dispatchGapHandle = null; }
+  }
+
+  resetDispatchCounters(): void {
+    this.unitDispatchCount.clear();
+    this.unitLifetimeDispatches.clear();
+    this.unitConsecutiveSkips.clear();
+  }
+
+  get lockBasePath(): string {
+    return this.originalBasePath || this.basePath;
+  }
+
+  completeCurrentUnit(): CompletedUnit | null {
+    if (!this.currentUnit) return null;
+    const done: CompletedUnit = { ...this.currentUnit, finishedAt: Date.now() };
+    this.completedUnits.push(done);
+    this.currentUnit = null;
+    return done;
+  }
+
+  reset(): void {
+    this.clearTimers();
+
+    // Lifecycle
+    this.active = false;
+    this.paused = false;
+    this.stepMode = false;
+    this.verbose = false;
+    this.cmdCtx = null;
+
+    // Paths
+    this.basePath = "";
+    this.originalBasePath = "";
+    this.gitService = null;
+
+    // Dispatch
+    this.unitDispatchCount.clear();
+    this.unitLifetimeDispatches.clear();
+    this.unitRecoveryCount.clear();
+    this.unitConsecutiveSkips.clear();
+    // Note: completedKeySet is intentionally NOT cleared — it persists
+    // across restarts to prevent re-dispatching completed units.
+
+    // Unit
+    this.currentUnit = null;
+    this.currentUnitRouting = null;
+    this.completedUnits = [];
+    this.currentMilestoneId = null;
+
+    // Model
+    this.autoModeStartModel = null;
+    this.originalModelId = null;
+    this.originalModelProvider = null;
+    this.lastBudgetAlertLevel = 0;
+
+    // Recovery
+    this.pendingCrashRecovery = null;
+    this.pendingVerificationRetry = null;
+    this.verificationRetryCount.clear();
+    this.pausedSessionFile = null;
+    this.resourceVersionOnStart = null;
+    this.lastStateRebuildAt = 0;
+
+    // Guards
+    this.handlingAgentEnd = false;
+    this.dispatching = false;
+    this.skipDepth = 0;
+    this.recentlyEvictedKeys.clear();
+
+    // Metrics
+    this.autoStartTime = 0;
+    this.lastPromptCharCount = undefined;
+    this.lastBaselineCharCount = undefined;
+    this.pendingQuickTasks = [];
+
+    // Signal handler
+    this.sigtermHandler = null;
+  }
+
+  toJSON(): Record<string, unknown> {
+    return {
+      active: this.active,
+      paused: this.paused,
+      stepMode: this.stepMode,
+      basePath: this.basePath,
+      currentMilestoneId: this.currentMilestoneId,
+      currentUnit: this.currentUnit,
+      completedUnits: this.completedUnits.length,
+      completedKeySet: this.completedKeySet.size,
+      unitDispatchCount: Object.fromEntries(this.unitDispatchCount),
+      dispatching: this.dispatching,
+      skipDepth: this.skipDepth,
+    };
+  }
+}

package/dist/resources/extensions/gsd/auto-budget.ts

@@ -0,0 +1,32 @@
+/**
+ * Budget alert level tracking and enforcement for auto-mode.
+ * Pure functions — no module state or side effects.
+ */
+
+import type { BudgetEnforcementMode } from "./types.js";
+
+export type BudgetAlertLevel = 0 | 75 | 80 | 90 | 100;
+
+export function getBudgetAlertLevel(budgetPct: number): BudgetAlertLevel {
+  if (budgetPct >= 1.0) return 100;
+  if (budgetPct >= 0.90) return 90;
+  if (budgetPct >= 0.80) return 80;
+  if (budgetPct >= 0.75) return 75;
+  return 0;
+}
+
+export function getNewBudgetAlertLevel(previousLevel: BudgetAlertLevel, budgetPct: number): BudgetAlertLevel | null {
+  const currentLevel = getBudgetAlertLevel(budgetPct);
+  if (currentLevel === 0 || currentLevel <= previousLevel) return null;
+  return currentLevel;
+}
+
+export function getBudgetEnforcementAction(
+  enforcement: BudgetEnforcementMode,
+  budgetPct: number,
+): "none" | "warn" | "pause" | "halt" {
+  if (budgetPct < 1.0) return "none";
+  if (enforcement === "halt") return "halt";
+  if (enforcement === "pause") return "pause";
+  return "warn";
+}

package/dist/resources/extensions/gsd/auto-dashboard.ts

@@ -6,7 +6,7 @@
  * or AutoContext dependency. State accessors are passed as callbacks.
  */
 
-import type { ExtensionContext, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import type { ExtensionContext, ExtensionCommandContext, SessionMessageEntry } from "@gsd/pi-coding-agent";
 import type { GSDState } from "./types.js";
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
@@ -159,6 +159,49 @@ export function formatWidgetTokens(count: number): string {
   return `${Math.round(count / 1000000)}M`;
 }
 
+// ─── ETA Estimation ──────────────────────────────────────────────────────────
+
+/**
+ * Estimate remaining time based on average unit duration from the metrics ledger.
+ * Returns a formatted string like "~12m remaining" or null if insufficient data.
+ */
+export function estimateTimeRemaining(): string | null {
+  const ledger = getLedger();
+  if (!ledger || ledger.units.length < 2) return null;
+
+  const sliceProgress = getRoadmapSlicesSync();
+  if (!sliceProgress || sliceProgress.total === 0) return null;
+
+  const remainingSlices = sliceProgress.total - sliceProgress.done;
+  if (remainingSlices <= 0) return null;
+
+  // Compute average duration per completed slice from the ledger
+  const completedSliceUnits = ledger.units.filter(
+    u => u.finishedAt > 0 && u.startedAt > 0,
+  );
+  if (completedSliceUnits.length < 2) return null;
+
+  const totalDuration = completedSliceUnits.reduce(
+    (sum, u) => sum + (u.finishedAt - u.startedAt), 0,
+  );
+  const avgDuration = totalDuration / completedSliceUnits.length;
+
+  // Rough estimate: remaining slices × average units per slice × avg duration
+  const completedSlices = sliceProgress.done || 1;
+  const unitsPerSlice = completedSliceUnits.length / completedSlices;
+  const estimatedMs = remainingSlices * unitsPerSlice * avgDuration;
+
+  if (estimatedMs < 5_000) return null; // Too small to display
+
+  const s = Math.floor(estimatedMs / 1000);
+  if (s < 60) return `~${s}s remaining`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `~${m}m remaining`;
+  const h = Math.floor(m / 60);
+  const rm = m % 60;
+  return rm > 0 ? `~${h}h ${rm}m remaining` : `~${h}h remaining`;
+}
+
 // ─── Slice Progress Cache ─────────────────────────────────────────────────────
 
 /** Cached slice progress for the widget — avoid async in render */
@@ -277,15 +320,16 @@ export function updateProgressWidget(
       tui.requestRender();
     }, 800);
 
-    // Refresh progress cache from disk every 5s so the widget reflects
+    // Refresh progress cache from disk every 15s so the widget reflects
     // task/slice completion mid-unit. Without this, the progress bar only
     // updates at dispatch time, appearing frozen during long-running units.
+    // 15s (vs 5s) reduces synchronous file I/O on the hot path.
     const progressRefreshTimer = mid ? setInterval(() => {
       try {
         updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
         cachedLines = undefined;
       } catch { /* non-fatal */ }
-    }, 5_000) : null;
+    }, 15_000) : null;
 
     return {
       render(width: number): string[] {
@@ -346,6 +390,12 @@ export function updateProgressWidget(
               meta += theme.fg("dim", `  ·  task ${taskNum}/${activeSliceTasks.total}`);
             }
 
+            // ETA estimate
+            const eta = estimateTimeRemaining();
+            if (eta) {
+              meta += theme.fg("dim", `  ·  ${eta}`);
+            }
+
             lines.push(truncateToWidth(`${pad}${bar}  ${meta}`, width));
           }
         }
@@ -370,13 +420,16 @@ export function updateProgressWidget(
           let totalCacheRead = 0, totalCacheWrite = 0;
           if (cmdCtx) {
             for (const entry of cmdCtx.sessionManager.getEntries()) {
-              if (entry.type === "message" && (entry as any).message?.role === "assistant") {
-                const u = (entry as any).message.usage;
-                if (u) {
-                  totalInput += u.input || 0;
-                  totalOutput += u.output || 0;
-                  totalCacheRead += u.cacheRead || 0;
-                  totalCacheWrite += u.cacheWrite || 0;
+              if (entry.type === "message") {
+                const msgEntry = entry as SessionMessageEntry;
+                if (msgEntry.message?.role === "assistant") {
+                  const u = (msgEntry.message as any).usage;
+                  if (u) {
+                    totalInput += u.input || 0;
+                    totalOutput += u.output || 0;
+                    totalCacheRead += u.cacheRead || 0;
+                    totalCacheWrite += u.cacheWrite || 0;
+                  }
                 }
               }
             }

package/dist/resources/extensions/gsd/auto-direct-dispatch.ts

@@ -0,0 +1,229 @@
+/**
+ * Direct phase dispatch — handles manual /gsd dispatch commands.
+ * Resolves phase name → unit type + prompt, creates a session, and sends the message.
+ */
+
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@gsd/pi-coding-agent";
+
+import { deriveState } from "./state.js";
+import { loadFile, parseRoadmap } from "./files.js";
+import {
+  resolveMilestoneFile, resolveSliceFile, relSliceFile,
+} from "./paths.js";
+import {
+  buildResearchSlicePrompt,
+  buildResearchMilestonePrompt,
+  buildPlanSlicePrompt,
+  buildPlanMilestonePrompt,
+  buildExecuteTaskPrompt,
+  buildCompleteSlicePrompt,
+  buildCompleteMilestonePrompt,
+  buildReassessRoadmapPrompt,
+  buildRunUatPrompt,
+  buildReplanSlicePrompt,
+} from "./auto-prompts.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { pauseAuto } from "./auto.js";
+
+export async function dispatchDirectPhase(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  phase: string,
+  base: string,
+): Promise<void> {
+  const state = await deriveState(base);
+  const mid = state.activeMilestone?.id;
+  const midTitle = state.activeMilestone?.title ?? "";
+
+  if (!mid) {
+    ctx.ui.notify("Cannot dispatch: no active milestone.", "warning");
+    return;
+  }
+
+  const normalized = phase.toLowerCase();
+  let unitType: string;
+  let unitId: string;
+  let prompt: string;
+
+  switch (normalized) {
+    case "research":
+    case "research-milestone":
+    case "research-slice": {
+      const isSlice = normalized === "research-slice" || (normalized === "research" && state.phase !== "pre-planning");
+      if (isSlice) {
+        const sid = state.activeSlice?.id;
+        const sTitle = state.activeSlice?.title ?? "";
+        if (!sid) {
+          ctx.ui.notify("Cannot dispatch research-slice: no active slice.", "warning");
+          return;
+        }
+
+        // When require_slice_discussion is enabled, pause auto-mode before
+        // each new slice so the user can discuss requirements first (#789).
+        const sliceContextFile = resolveSliceFile(base, mid, sid, "CONTEXT");
+        const requireDiscussion = loadEffectiveGSDPreferences()?.preferences?.phases?.require_slice_discussion;
+        if (requireDiscussion && !sliceContextFile) {
+          ctx.ui.notify(
+            `Slice ${sid} requires discussion before planning. Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
+            "info",
+          );
+          await pauseAuto(ctx, pi);
+          return;
+        }
+
+        unitType = "research-slice";
+        unitId = `${mid}/${sid}`;
+        prompt = await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, base);
+      } else {
+        unitType = "research-milestone";
+        unitId = mid;
+        prompt = await buildResearchMilestonePrompt(mid, midTitle, base);
+      }
+      break;
+    }
+
+    case "plan":
+    case "plan-milestone":
+    case "plan-slice": {
+      const isSlice = normalized === "plan-slice" || (normalized === "plan" && state.phase !== "pre-planning");
+      if (isSlice) {
+        const sid = state.activeSlice?.id;
+        const sTitle = state.activeSlice?.title ?? "";
+        if (!sid) {
+          ctx.ui.notify("Cannot dispatch plan-slice: no active slice.", "warning");
+          return;
+        }
+        unitType = "plan-slice";
+        unitId = `${mid}/${sid}`;
+        prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base);
+      } else {
+        unitType = "plan-milestone";
+        unitId = mid;
+        prompt = await buildPlanMilestonePrompt(mid, midTitle, base);
+      }
+      break;
+    }
+
+    case "execute":
+    case "execute-task": {
+      const sid = state.activeSlice?.id;
+      const sTitle = state.activeSlice?.title ?? "";
+      const tid = state.activeTask?.id;
+      const tTitle = state.activeTask?.title ?? "";
+      if (!sid) {
+        ctx.ui.notify("Cannot dispatch execute-task: no active slice.", "warning");
+        return;
+      }
+      if (!tid) {
+        ctx.ui.notify("Cannot dispatch execute-task: no active task.", "warning");
+        return;
+      }
+      unitType = "execute-task";
+      unitId = `${mid}/${sid}/${tid}`;
+      prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base);
+      break;
+    }
+
+    case "complete":
+    case "complete-slice":
+    case "complete-milestone": {
+      const isSlice = normalized === "complete-slice" || (normalized === "complete" && state.phase === "summarizing");
+      if (isSlice) {
+        const sid = state.activeSlice?.id;
+        const sTitle = state.activeSlice?.title ?? "";
+        if (!sid) {
+          ctx.ui.notify("Cannot dispatch complete-slice: no active slice.", "warning");
+          return;
+        }
+        unitType = "complete-slice";
+        unitId = `${mid}/${sid}`;
+        prompt = await buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base);
+      } else {
+        unitType = "complete-milestone";
+        unitId = mid;
+        prompt = await buildCompleteMilestonePrompt(mid, midTitle, base);
+      }
+      break;
+    }
+
+    case "reassess":
+    case "reassess-roadmap": {
+      const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+      const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+      if (!roadmapContent) {
+        ctx.ui.notify("Cannot dispatch reassess-roadmap: no roadmap found.", "warning");
+        return;
+      }
+      const roadmap = parseRoadmap(roadmapContent);
+      const completedSlices = roadmap.slices.filter(s => s.done);
+      if (completedSlices.length === 0) {
+        ctx.ui.notify("Cannot dispatch reassess-roadmap: no completed slices.", "warning");
+        return;
+      }
+      const completedSliceId = completedSlices[completedSlices.length - 1].id;
+      unitType = "reassess-roadmap";
+      unitId = `${mid}/${completedSliceId}`;
+      prompt = await buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, base);
+      break;
+    }
+
+    case "uat":
+    case "run-uat": {
+      const sid = state.activeSlice?.id;
+      if (!sid) {
+        ctx.ui.notify("Cannot dispatch run-uat: no active slice.", "warning");
+        return;
+      }
+      const uatFile = resolveSliceFile(base, mid, sid, "UAT");
+      if (!uatFile) {
+        ctx.ui.notify("Cannot dispatch run-uat: no UAT file found.", "warning");
+        return;
+      }
+      const uatContent = await loadFile(uatFile);
+      if (!uatContent) {
+        ctx.ui.notify("Cannot dispatch run-uat: UAT file is empty.", "warning");
+        return;
+      }
+      const uatPath = relSliceFile(base, mid, sid, "UAT");
+      unitType = "run-uat";
+      unitId = `${mid}/${sid}`;
+      prompt = await buildRunUatPrompt(mid, sid, uatPath, uatContent, base);
+      break;
+    }
+
+    case "replan":
+    case "replan-slice": {
+      const sid = state.activeSlice?.id;
+      const sTitle = state.activeSlice?.title ?? "";
+      if (!sid) {
+        ctx.ui.notify("Cannot dispatch replan-slice: no active slice.", "warning");
+        return;
+      }
+      unitType = "replan-slice";
+      unitId = `${mid}/${sid}`;
+      prompt = await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base);
+      break;
+    }
+
+    default:
+      ctx.ui.notify(
+        `Unknown phase "${phase}". Valid phases: research, plan, execute, complete, reassess, uat, replan.`,
+        "warning",
+      );
+      return;
+  }
+
+  ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
+  const result = await ctx.newSession();
+  if (result.cancelled) {
+    ctx.ui.notify("Session creation cancelled.", "warning");
+    return;
+  }
+  pi.sendMessage(
+    { customType: "gsd-dispatch", content: prompt, display: false },
+    { triggerTurn: true },
+  );
+}