xtrm-tools 2.4.3 → 2.4.6

package/config/pi/extensions/plan-mode/utils.ts

@@ -3,6 +3,10 @@
  * Extracted for testability.
  */
 
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
 // Destructive commands blocked in plan mode
 const DESTRUCTIVE_PATTERNS = [
 	/\brm\b/i,
@@ -134,7 +138,8 @@ export function extractTodoItems(message: string): TodoItem[] {
 	const planSection = message.slice(message.indexOf(headerMatch[0]) + headerMatch[0].length);
 	const numberedPattern = /^\s*(\d+)[.)]\s+\*{0,2}([^*\n]+)/gm;
 
-	for (const match of planSection.matchAll(numberedPattern)) {
+	const matches = Array.from(planSection.matchAll(numberedPattern));
+	for (const match of matches) {
 		const text = match[2]
 			.trim()
 			.replace(/\*{1,2}$/, "")
@@ -151,7 +156,8 @@ export function extractTodoItems(message: string): TodoItem[] {
 
 export function extractDoneSteps(message: string): number[] {
 	const steps: number[] = [];
-	for (const match of message.matchAll(/\[DONE:(\d+)\]/gi)) {
+	const matches = Array.from(message.matchAll(/\[DONE:(\d+)\]/gi));
+	for (const match of matches) {
 		const step = Number(match[1]);
 		if (Number.isFinite(step)) steps.push(step);
 	}
@@ -166,3 +172,153 @@ export function markCompletedSteps(text: string, items: TodoItem[]): number {
 	}
 	return doneSteps.length;
 }
+
+// =============================================================================
+// bd (beads) Integration Functions
+// =============================================================================
+
+/**
+ * Extract short ID from full bd issue ID.
+ * Example: "jaggers-agent-tools-xr9b.1" → "xr9b.1"
+ */
+export function getShortId(fullId: string): string {
+	const parts = fullId.split("-");
+	// Last part is the ID (e.g., "xr9b.1")
+	return parts[parts.length - 1];
+}
+
+/**
+ * Check if a directory is a beads project (has .beads directory).
+ */
+export function isBeadsProject(cwd: string): boolean {
+	return existsSync(join(cwd, ".beads"));
+}
+
+/**
+ * Derive epic title from user prompt or conversation messages.
+ */
+export function deriveEpicTitle(messages: Array<{ role: string; content?: unknown }>): string {
+	// Find the last user message
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "user") {
+			const content = msg.content;
+			if (typeof content === "string") {
+				// Extract first sentence or first 50 chars
+				const firstSentence = content.split(/[.!?\n]/)[0].trim();
+				if (firstSentence.length > 10 && firstSentence.length < 80) {
+					return firstSentence;
+				}
+				if (firstSentence.length >= 80) {
+					return `${firstSentence.slice(0, 77)}...`;
+				}
+			}
+		}
+	}
+	return "Plan execution";
+}
+
+/**
+ * Run a bd command and return the result.
+ */
+function runBd(args: string[], cwd: string): { stdout: string; stderr: string; status: number } {
+	const result = spawnSync("bd", args, {
+		cwd,
+		encoding: "utf8",
+		timeout: 30000,
+	});
+	return {
+		stdout: result.stdout || "",
+		stderr: result.stderr || "",
+		status: result.status ?? 1,
+	};
+}
+
+/**
+ * Create an epic in bd.
+ */
+export function bdCreateEpic(title: string, cwd: string): { id: string; title: string } | null {
+	const result = runBd(["create", title, "-t", "epic", "-p", "1", "--json"], cwd);
+	if (result.status === 0) {
+		try {
+			const data = JSON.parse(result.stdout);
+			if (Array.isArray(data) && data[0]) {
+				return { id: data[0].id, title: data[0].title };
+			}
+		} catch {
+			// Parse the ID from stdout if JSON parse fails
+			const match = result.stdout.match(/Created issue:\s*(\S+)/);
+			if (match) {
+				return { id: match[1], title };
+			}
+		}
+	}
+	return null;
+}
+
+/**
+ * Create a task issue in bd under an epic.
+ */
+export function bdCreateIssue(
+	title: string,
+	description: string,
+	parentId: string,
+	cwd: string,
+): { id: string; title: string } | null {
+	const result = runBd(
+		["create", title, "-t", "task", "-p", "1", "--parent", parentId, "-d", description, "--json"],
+		cwd,
+	);
+	if (result.status === 0) {
+		try {
+			const data = JSON.parse(result.stdout);
+			if (Array.isArray(data) && data[0]) {
+				return { id: data[0].id, title: data[0].title };
+			}
+		} catch {
+			const match = result.stdout.match(/Created issue:\s*(\S+)/);
+			if (match) {
+				return { id: match[1], title };
+			}
+		}
+	}
+	return null;
+}
+
+/**
+ * Claim an issue in bd.
+ */
+export function bdClaim(issueId: string, cwd: string): boolean {
+	const result = runBd(["update", issueId, "--claim"], cwd);
+	return result.status === 0;
+}
+
+/**
+ * Result of creating plan issues.
+ */
+export interface PlanIssuesResult {
+	epic: { id: string; title: string };
+	issues: Array<{ id: string; title: string }>;
+}
+
+/**
+ * Create an epic and issues from todo items.
+ */
+export function createPlanIssues(
+	epicTitle: string,
+	todos: TodoItem[],
+	cwd: string,
+): PlanIssuesResult | null {
+	const epic = bdCreateEpic(epicTitle, cwd);
+	if (!epic) return null;
+
+	const issues: Array<{ id: string; title: string }> = [];
+	for (const todo of todos) {
+		const issue = bdCreateIssue(todo.text, `Step ${todo.step} of plan: ${epicTitle}`, epic.id, cwd);
+		if (issue) {
+			issues.push(issue);
+		}
+	}
+
+	return { epic, issues };
+}

package/config/pi/extensions/session-flow.ts

@@ -84,7 +84,12 @@ export default function (pi: ExtensionAPI) {
 
 		const ensured = await ensureWorktreeSessionState(cwd, issueId);
 		if (ensured.ok) {
-			const text = `\n\n🧭 Session Flow: ${ensured.message}`;
+			const state = readSessionState(cwd);
+			const worktreePath = state?.worktreePath;
+			const nextStep = worktreePath
+				? `\nNext: cd ${worktreePath} && pi  (sandboxed session)`
+				: "";
+			const text = `\n\n🧭 Session Flow: ${ensured.message}${nextStep}`;
 			return { content: [...event.content, { type: "text", text }] };
 		}
 		return undefined;
@@ -99,18 +104,27 @@ export default function (pi: ExtensionAPI) {
 		if (state.phase === "waiting-merge" || state.phase === "pending-cleanup") {
 			const pr = state.prNumber != null ? `#${state.prNumber}` : "(pending PR)";
 			const url = state.prUrl ? ` ${state.prUrl}` : "";
-			pi.sendUserMessage(`🚫 PR ${pr}${url} not yet merged. Run: xtrm finish`);
+			pi.sendUserMessage(
+				`⚠ PR ${pr}${url} is still pending. xtrm finish is deprecated for Pi workflow. ` +
+				"Use xtpi publish (when available) and external merge/cleanup steps.",
+			);
 			return undefined;
 		}
 
 		if (state.phase === "conflicting") {
 			const files = state.conflictFiles?.length ? state.conflictFiles.join(", ") : "unknown files";
-			pi.sendUserMessage(`🚫 Merge conflicts in: ${files}. Resolve, push, then: xtrm finish`);
+			pi.sendUserMessage(
+				`⚠ Conflicts in: ${files}. xtrm finish is deprecated for Pi workflow. ` +
+				"Resolve conflicts, then continue with publish-only flow.",
+			);
 			return undefined;
 		}
 
 		if (state.phase === "claimed" || state.phase === "phase1-done") {
-			pi.sendUserMessage(`⚠ Session has an active worktree at ${state.worktreePath}. Consider running: xtrm finish`);
+			pi.sendUserMessage(
+				`⚠ Session has an active worktree at ${state.worktreePath}. ` +
+				"Use publish-only workflow (no automatic push/PR/merge).",
+			);
 		}
 		return undefined;
 	});

package/config/pi/settings.json.template

@@ -12,5 +12,5 @@
   ],
   "steeringMode": "all",
   "followUpMode": "all",
-  "hideThinkingBlock": false
+  "hideThinkingBlock": true
 }

package/hooks/beads-claim-sync.mjs

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 // beads-claim-sync — PostToolUse hook
-// Auto-sets kv claim on bd update --claim; auto-clears on bd close.
-// Also bootstraps worktree-first session state for xtrm finish workflow.
+// bd update --claim → set kv claim
+// bd close         → auto-commit staged changes, set closed-this-session kv for memory gate
 
 import { spawnSync } from 'node:child_process';
-import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { writeSessionState } from './session-state.mjs';
+import { resolveSessionId } from './beads-gate-utils.mjs';
 
 function readInput() {
   try {
@@ -46,103 +46,56 @@ function runGit(args, cwd, timeout = 8000) {
   });
 }
 
-function getRepoRoot(cwd) {
-  const result = runGit(['rev-parse', '--show-toplevel'], cwd);
-  if (result.status !== 0) return null;
-  return result.stdout.trim();
+function runBd(args, cwd, timeout = 5000) {
+  return spawnSync('bd', args, {
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    timeout,
+  });
 }
 
-function inLinkedWorktree(cwd) {
-  const gitDir = runGit(['rev-parse', '--git-dir'], cwd);
-  const gitCommonDir = runGit(['rev-parse', '--git-common-dir'], cwd);
-  if (gitDir.status !== 0 || gitCommonDir.status !== 0) return false;
-  return gitDir.stdout.trim() !== gitCommonDir.stdout.trim();
+function hasGitChanges(cwd) {
+  const result = runGit(['status', '--porcelain'], cwd);
+  if (result.status !== 0) return false;
+  return result.stdout.trim().length > 0;
 }
 
-function ensureWorktreeForClaim(cwd, issueId) {
-  const repoRoot = getRepoRoot(cwd);
-  if (!repoRoot) return { created: false, reason: 'not-git' };
+function getCloseReason(cwd, issueId, command) {
+  // 1. Parse --reason "..." from the command itself (fastest, no extra call)
+  const reasonMatch = command.match(/--reason[=\s]+["']([^"']+)["']/);
+  if (reasonMatch) return reasonMatch[1].trim();
 
-  if (inLinkedWorktree(cwd)) {
-    return { created: false, reason: 'already-worktree', repoRoot };
+  // 2. Fall back to bd show <id> --json
+  const show = runBd(['show', issueId, '--json'], cwd);
+  if (show.status === 0 && show.stdout) {
+    try {
+      const parsed = JSON.parse(show.stdout);
+      const reason = parsed?.[0]?.close_reason;
+      if (typeof reason === 'string' && reason.trim().length > 0) return reason.trim();
+    } catch { /* fall through */ }
   }
 
-  const overstoryDir = join(repoRoot, '.overstory');
-  const worktreesBase = existsSync(overstoryDir)
-    ? join(overstoryDir, 'worktrees')
-    : join(repoRoot, '.worktrees');
-
-  mkdirSync(worktreesBase, { recursive: true });
-
-  const branch = `feature/${issueId}`;
-  const worktreePath = join(worktreesBase, issueId);
+  return `Close ${issueId}`;
+}
 
-  if (existsSync(worktreePath)) {
-    // Already created previously — rewrite state file for continuity.
-    try {
-      const stateFile = writeSessionState({
-        issueId,
-        branch,
-        worktreePath,
-        prNumber: null,
-        prUrl: null,
-        phase: 'claimed',
-        conflictFiles: [],
-      }, { cwd: repoRoot });
-      return { created: false, reason: 'exists', repoRoot, branch, worktreePath, stateFile };
-    } catch {
-      return { created: false, reason: 'exists', repoRoot, branch, worktreePath };
-    }
+function autoCommit(cwd, issueId, command) {
+  if (!hasGitChanges(cwd)) {
+    return { ok: true, message: 'No changes detected — auto-commit skipped.' };
   }
 
-  const branchExists = runGit(['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], repoRoot).status === 0;
-  const addArgs = branchExists
-    ? ['worktree', 'add', worktreePath, branch]
-    : ['worktree', 'add', worktreePath, '-b', branch];
-
-  const addResult = runGit(addArgs, repoRoot, 20000);
-  if (addResult.status !== 0) {
-    return {
-      created: false,
-      reason: 'create-failed',
-      repoRoot,
-      branch,
-      worktreePath,
-      error: (addResult.stderr || addResult.stdout || '').trim(),
-    };
+  const reason = getCloseReason(cwd, issueId, command);
+  const commitMessage = `${reason} (${issueId})`;
+  const result = runGit(['commit', '-am', commitMessage], cwd, 15000);
+  if (result.status !== 0) {
+    const err = (result.stderr || result.stdout || '').trim();
+    return { ok: false, message: `Auto-commit failed: ${err || 'unknown error'}` };
   }
 
-  try {
-    const stateFile = writeSessionState({
-      issueId,
-      branch,
-      worktreePath,
-      prNumber: null,
-      prUrl: null,
-      phase: 'claimed',
-      conflictFiles: [],
-    }, { cwd: repoRoot });
-
-    return {
-      created: true,
-      reason: 'created',
-      repoRoot,
-      branch,
-      worktreePath,
-      stateFile,
-    };
-  } catch (err) {
-    return {
-      created: true,
-      reason: 'created-state-write-failed',
-      repoRoot,
-      branch,
-      worktreePath,
-      error: String(err?.message || err),
-    };
-  }
+  return { ok: true, message: `Auto-committed: \`${commitMessage}\`` };
 }
 
+
 function main() {
   const input = readInput();
   if (!input || input.hook_event_name !== 'PostToolUse') process.exit(0);
@@ -152,12 +105,7 @@ function main() {
   if (!isBeadsProject(cwd)) process.exit(0);
 
   const command = input.tool_input?.command || '';
-  const sessionId = input.session_id ?? input.sessionId;
-
-  if (!sessionId) {
-    process.stderr.write('Beads claim sync: no session_id in hook input\n');
-    process.exit(0);
-  }
+  const sessionId = resolveSessionId(input);
 
   // Auto-claim: bd update <id> --claim (fire regardless of exit code — bd returns 1 for "already in_progress")
   if (/\bbd\s+update\b/.test(command) && /--claim\b/.test(command)) {
@@ -176,33 +124,22 @@ function main() {
         process.exit(0);
       }
 
-      const wt = ensureWorktreeForClaim(cwd, issueId);
-      const details = [];
-      if (wt.created) {
-        details.push(`🧭 **Session Flow**: Worktree created: \`${wt.worktreePath}\`  Branch: \`${wt.branch}\``);
-      } else if (wt.reason === 'exists') {
-        details.push(`🧭 **Session Flow**: Worktree already exists: \`${wt.worktreePath}\`  Branch: \`${wt.branch}\``);
-      } else if (wt.reason === 'already-worktree') {
-        details.push('🧭 **Session Flow**: Already in a linked worktree — skipping nested worktree creation.');
-      } else if (wt.reason === 'create-failed') {
-        const err = wt.error ? `\nWarning: ${wt.error}` : '';
-        details.push(`⚠️ **Session Flow**: Worktree creation failed for \`${issueId}\`. Continuing without blocking claim.${err}`);
-      }
-
       process.stdout.write(JSON.stringify({
-        additionalContext: `\n✅ **Beads**: Session \`${sessionId}\` claimed issue \`${issueId}\`.${details.length ? `\n${details.join('\n')}` : ''}`,
+        additionalContext: `\n✅ **Beads**: Session \`${sessionId}\` claimed issue \`${issueId}\`.`,
       }));
       process.stdout.write('\n');
       process.exit(0);
     }
   }
 
-  // On bd close: mark as closed-this-session for memory gate (don't clear claim yet)
-  // Memory gate will clear the claim after user acknowledges memory prompt
+  // On bd close: auto-commit staged changes, then mark closed-this-session for memory gate
   if (/\bbd\s+close\b/.test(command) && commandSucceeded(input)) {
     const match = command.match(/\bbd\s+close\s+(\S+)/);
     const closedIssueId = match?.[1];
-    
+
+    // Auto-commit before marking the gate (no-op if clean)
+    const commit = closedIssueId ? autoCommit(cwd, closedIssueId, command) : null;
+
     // Mark this issue as closed this session (memory gate reads this)
     if (closedIssueId) {
       spawnSync('bd', ['kv', 'set', `closed-this-session:${sessionId}`, closedIssueId], {
@@ -212,8 +149,12 @@ function main() {
       });
     }
 
+    const commitLine = commit
+      ? `\n${commit.ok ? '✅' : '⚠️'} **Session Flow**: ${commit.message}`
+      : '';
+
     process.stdout.write(JSON.stringify({
-      additionalContext: `\n🔓 **Beads**: Issue closed. Memory gate will prompt on session end.`,
+      additionalContext: `\n🔓 **Beads**: Issue closed.${commitLine}\nEvaluate insights, then acknowledge:\n  \`bd remember "<insight>"\` (or note "nothing")\n  \`touch .beads/.memory-gate-done\``,
     }));
     process.stdout.write('\n');
     process.exit(0);

package/hooks/beads-commit-gate.mjs

@@ -13,20 +13,35 @@ import {
   resolveClaimAndWorkState,
   decideCommitGate,
 } from './beads-gate-core.mjs';
-import { withSafeBdContext } from './beads-gate-utils.mjs';
-import { commitBlockMessage } from './beads-gate-messages.mjs';
+import { withSafeBdContext, isMemoryGatePending, isMemoryAckCommand } from './beads-gate-utils.mjs';
+import { commitBlockMessage, memoryGatePendingMessage } from './beads-gate-messages.mjs';
 
 const input = readHookInput();
 if (!input) process.exit(0);
 
-// Only intercept git commit commands
 if ((input.tool_name ?? '') !== 'Bash') process.exit(0);
-if (!/\bgit\s+commit\b/.test(input.tool_input?.command ?? '')) process.exit(0);
+
+const command = input.tool_input?.command ?? '';
+// Strip quoted strings to avoid matching patterns inside --reason "..." or similar args
+const commandUnquoted = command.replace(/'[^']*'|"[^"]*"/g, '');
 
 withSafeBdContext(() => {
   const ctx = resolveSessionContext(input);
   if (!ctx || !ctx.isBeadsProject) process.exit(0);
 
+  // Memory gate: block all Bash except acknowledgment commands while gate pending
+  if (ctx.sessionId && isMemoryGatePending(ctx.sessionId, ctx.cwd)) {
+    if (!isMemoryAckCommand(commandUnquoted)) {
+      process.stdout.write(JSON.stringify({ decision: 'block', reason: memoryGatePendingMessage() }));
+      process.stdout.write('\n');
+      process.exit(0);
+    }
+    process.exit(0); // memory-ack command — allow
+  }
+
+  // Only intercept git commit for the claim-gate check
+  if (!/\bgit\s+commit\b/.test(commandUnquoted)) process.exit(0);
+
   const state = resolveClaimAndWorkState(ctx);
   const decision = decideCommitGate(ctx, state);
 

package/hooks/beads-compact-restore.mjs

@@ -7,7 +7,6 @@
 import { execSync } from 'node:child_process';
 import { readFileSync, existsSync, unlinkSync } from 'node:fs';
 import path from 'node:path';
-import { writeSessionState } from './session-state.mjs';
 
 let input;
 try {
@@ -22,14 +21,12 @@ const lastActivePath = path.join(cwd, '.beads', '.last_active');
 if (!existsSync(lastActivePath)) process.exit(0);
 
 let ids = [];
-let sessionState = null;
 
 try {
   const raw = readFileSync(lastActivePath, 'utf8').trim();
   if (raw.startsWith('{')) {
     const parsed = JSON.parse(raw);
     ids = Array.isArray(parsed.ids) ? parsed.ids.filter(Boolean) : [];
-    sessionState = parsed.sessionState ?? null;
   } else {
     // Backward compatibility: legacy newline format
     ids = raw.split('\n').filter(Boolean);
@@ -56,27 +53,8 @@ for (const id of ids) {
   }
 }
 
-let restoredSession = false;
-if (sessionState && typeof sessionState === 'object') {
-  try {
-    writeSessionState(sessionState, { cwd });
-    restoredSession = true;
-  } catch {
-    // fail open
-  }
-}
-
-if (restored > 0 || restoredSession) {
-  const lines = [];
-  if (restored > 0) {
-    lines.push(`Restored ${restored} in_progress issue${restored === 1 ? '' : 's'} from last session before compaction.`);
-  }
-
-  if (restoredSession && (sessionState.phase === 'waiting-merge' || sessionState.phase === 'pending-cleanup')) {
-    const pr = sessionState.prNumber != null ? `#${sessionState.prNumber}` : '(pending PR)';
-    const prUrl = sessionState.prUrl ? ` ${sessionState.prUrl}` : '';
-    lines.push(`RESUME: Run xtrm finish — PR ${pr}${prUrl} waiting for merge. Worktree: ${sessionState.worktreePath}`);
-  }
+if (restored > 0) {
+  const lines = [`Restored ${restored} in_progress issue${restored === 1 ? '' : 's'} from last session before compaction.`];
 
   process.stdout.write(
     JSON.stringify({

package/hooks/beads-compact-save.mjs

@@ -7,7 +7,6 @@
 import { execSync } from 'node:child_process';
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import path from 'node:path';
-import { readSessionState } from './session-state.mjs';
 
 let input;
 try {
@@ -40,38 +39,13 @@ for (const line of output.split('\n')) {
   if (match) ids.push(match[1]);
 }
 
-const sessionState = readSessionState(cwd);
 const bundle = {
   ids,
-  sessionState: sessionState ? {
-    issueId: sessionState.issueId,
-    branch: sessionState.branch,
-    worktreePath: sessionState.worktreePath,
-    prNumber: sessionState.prNumber,
-    prUrl: sessionState.prUrl,
-    phase: sessionState.phase,
-    conflictFiles: Array.isArray(sessionState.conflictFiles) ? sessionState.conflictFiles : [],
-    startedAt: sessionState.startedAt,
-    lastChecked: sessionState.lastChecked,
-  } : null,
   savedAt: new Date().toISOString(),
 };
 
-if (bundle.ids.length === 0 && !bundle.sessionState) process.exit(0);
+if (bundle.ids.length === 0) process.exit(0);
 
 writeFileSync(path.join(beadsDir, '.last_active'), JSON.stringify(bundle, null, 2) + '\n', 'utf8');
 
-if (bundle.sessionState?.phase === 'waiting-merge') {
-  const pr = bundle.sessionState.prNumber != null ? `#${bundle.sessionState.prNumber}` : '(pending PR)';
-  process.stdout.write(
-    JSON.stringify({
-      hookSpecificOutput: {
-        hookEventName: 'PreCompact',
-        additionalSystemPrompt:
-          `PENDING: xtrm finish waiting for PR ${pr} to merge. Re-run xtrm finish to resume.`,
-      },
-    }) + '\n',
-  );
-}
-
 process.exit(0);

package/hooks/beads-edit-gate.mjs

@@ -13,8 +13,8 @@ import {
   resolveClaimAndWorkState,
   decideEditGate,
 } from './beads-gate-core.mjs';
-import { withSafeBdContext } from './beads-gate-utils.mjs';
-import { editBlockMessage, editBlockFallbackMessage } from './beads-gate-messages.mjs';
+import { withSafeBdContext, isMemoryGatePending } from './beads-gate-utils.mjs';
+import { editBlockMessage, editBlockFallbackMessage, memoryGatePendingMessage } from './beads-gate-messages.mjs';
 
 const input = readHookInput();
 if (!input) process.exit(0);
@@ -23,6 +23,13 @@ withSafeBdContext(() => {
   const ctx = resolveSessionContext(input);
   if (!ctx || !ctx.isBeadsProject) process.exit(0);
 
+  // Memory gate takes priority: block edits while pending acknowledgment
+  if (ctx.sessionId && isMemoryGatePending(ctx.sessionId, ctx.cwd)) {
+    process.stdout.write(JSON.stringify({ decision: 'block', reason: memoryGatePendingMessage() }));
+    process.stdout.write('\n');
+    process.exit(0);
+  }
+
   const state = resolveClaimAndWorkState(ctx);
   const decision = decideEditGate(ctx, state);