indusagi-coding-agent 0.50.0

package/examples/extensions/doom-overlay/doom-engine.ts

@@ -0,0 +1,173 @@
+/**
+ * DOOM Engine - WebAssembly wrapper for doomgeneric
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export interface DoomModule {
+	_doomgeneric_Create: (argc: number, argv: number) => void;
+	_doomgeneric_Tick: () => void;
+	_DG_GetFrameBuffer: () => number;
+	_DG_GetScreenWidth: () => number;
+	_DG_GetScreenHeight: () => number;
+	_DG_PushKeyEvent: (pressed: number, key: number) => void;
+	_malloc: (size: number) => number;
+	_free: (ptr: number) => void;
+	HEAPU8: Uint8Array;
+	HEAPU32: Uint32Array;
+	FS_createDataFile: (parent: string, name: string, data: number[], canRead: boolean, canWrite: boolean) => void;
+	FS_createPath: (parent: string, path: string, canRead: boolean, canWrite: boolean) => string;
+	setValue: (ptr: number, value: number, type: string) => void;
+	getValue: (ptr: number, type: string) => number;
+}
+
+export class DoomEngine {
+	private module: DoomModule | null = null;
+	private frameBufferPtr: number = 0;
+	private initialized = false;
+	private wadPath: string;
+	private _width = 640;
+	private _height = 400;
+
+	constructor(wadPath: string) {
+		this.wadPath = wadPath;
+	}
+
+	get width(): number {
+		return this._width;
+	}
+
+	get height(): number {
+		return this._height;
+	}
+
+	async init(): Promise<void> {
+		// Locate WASM build
+		const __dirname = dirname(fileURLToPath(import.meta.url));
+		const buildDir = join(__dirname, "doom", "build");
+		const doomJsPath = join(buildDir, "doom.js");
+
+		if (!existsSync(doomJsPath)) {
+			throw new Error(`WASM not found at ${doomJsPath}. Run ./doom/build.sh first`);
+		}
+
+		// Read WAD file
+		const wadData = readFileSync(this.wadPath);
+		const wadArray = Array.from(new Uint8Array(wadData));
+
+		// Load WASM module - eval to bypass jiti completely
+		const doomJsCode = readFileSync(doomJsPath, "utf-8");
+		const moduleExports: { exports: unknown } = { exports: {} };
+		const nativeRequire = createRequire(doomJsPath);
+		const moduleFunc = new Function("module", "exports", "__dirname", "__filename", "require", doomJsCode);
+		moduleFunc(moduleExports, moduleExports.exports, buildDir, doomJsPath, nativeRequire);
+		const createDoomModule = moduleExports.exports as (config: unknown) => Promise<DoomModule>;
+
+		const moduleConfig = {
+			locateFile: (path: string) => {
+				if (path.endsWith(".wasm")) {
+					return join(buildDir, path);
+				}
+				return path;
+			},
+			print: () => {},
+			printErr: () => {},
+			preRun: [
+				(module: DoomModule) => {
+					// Create /doom directory and add WAD
+					module.FS_createPath("/", "doom", true, true);
+					module.FS_createDataFile("/doom", "doom1.wad", wadArray, true, false);
+				},
+			],
+		};
+
+		this.module = await createDoomModule(moduleConfig);
+		if (!this.module) {
+			throw new Error("Failed to initialize DOOM module");
+		}
+
+		// Initialize DOOM
+		this.initDoom();
+
+		// Get framebuffer info
+		this.frameBufferPtr = this.module._DG_GetFrameBuffer();
+		this._width = this.module._DG_GetScreenWidth();
+		this._height = this.module._DG_GetScreenHeight();
+		this.initialized = true;
+	}
+
+	private initDoom(): void {
+		if (!this.module) return;
+
+		const args = ["doom", "-iwad", "/doom/doom1.wad"];
+		const argPtrs: number[] = [];
+
+		for (const arg of args) {
+			const ptr = this.module._malloc(arg.length + 1);
+			for (let i = 0; i < arg.length; i++) {
+				this.module.setValue(ptr + i, arg.charCodeAt(i), "i8");
+			}
+			this.module.setValue(ptr + arg.length, 0, "i8");
+			argPtrs.push(ptr);
+		}
+
+		const argvPtr = this.module._malloc(argPtrs.length * 4);
+		for (let i = 0; i < argPtrs.length; i++) {
+			this.module.setValue(argvPtr + i * 4, argPtrs[i]!, "i32");
+		}
+
+		this.module._doomgeneric_Create(args.length, argvPtr);
+
+		for (const ptr of argPtrs) {
+			this.module._free(ptr);
+		}
+		this.module._free(argvPtr);
+	}
+
+	/**
+	 * Run one game tick
+	 */
+	tick(): void {
+		if (!this.module || !this.initialized) return;
+		this.module._doomgeneric_Tick();
+	}
+
+	/**
+	 * Get current frame as RGBA pixel data
+	 * DOOM outputs ARGB, we convert to RGBA
+	 */
+	getFrameRGBA(): Uint8Array {
+		if (!this.module || !this.initialized) {
+			return new Uint8Array(this._width * this._height * 4);
+		}
+
+		const pixels = this._width * this._height;
+		const buffer = new Uint8Array(pixels * 4);
+
+		for (let i = 0; i < pixels; i++) {
+			const argb = this.module.getValue(this.frameBufferPtr + i * 4, "i32");
+			const offset = i * 4;
+			buffer[offset + 0] = (argb >> 16) & 0xff; // R
+			buffer[offset + 1] = (argb >> 8) & 0xff; // G
+			buffer[offset + 2] = argb & 0xff; // B
+			buffer[offset + 3] = 255; // A
+		}
+
+		return buffer;
+	}
+
+	/**
+	 * Push a key event
+	 */
+	pushKey(pressed: boolean, key: number): void {
+		if (!this.module || !this.initialized) return;
+		this.module._DG_PushKeyEvent(pressed ? 1 : 0, key);
+	}
+
+	isInitialized(): boolean {
+		return this.initialized;
+	}
+}

package/examples/extensions/doom-overlay/doom-keys.ts

@@ -0,0 +1,105 @@
+/**
+ * DOOM key codes (from doomkeys.h)
+ */
+export const DoomKeys = {
+	KEY_RIGHTARROW: 0xae,
+	KEY_LEFTARROW: 0xac,
+	KEY_UPARROW: 0xad,
+	KEY_DOWNARROW: 0xaf,
+	KEY_STRAFE_L: 0xa0,
+	KEY_STRAFE_R: 0xa1,
+	KEY_USE: 0xa2,
+	KEY_FIRE: 0xa3,
+	KEY_ESCAPE: 27,
+	KEY_ENTER: 13,
+	KEY_TAB: 9,
+	KEY_F1: 0x80 + 0x3b,
+	KEY_F2: 0x80 + 0x3c,
+	KEY_F3: 0x80 + 0x3d,
+	KEY_F4: 0x80 + 0x3e,
+	KEY_F5: 0x80 + 0x3f,
+	KEY_F6: 0x80 + 0x40,
+	KEY_F7: 0x80 + 0x41,
+	KEY_F8: 0x80 + 0x42,
+	KEY_F9: 0x80 + 0x43,
+	KEY_F10: 0x80 + 0x44,
+	KEY_F11: 0x80 + 0x57,
+	KEY_F12: 0x80 + 0x58,
+	KEY_BACKSPACE: 127,
+	KEY_PAUSE: 0xff,
+	KEY_EQUALS: 0x3d,
+	KEY_MINUS: 0x2d,
+	KEY_RSHIFT: 0x80 + 0x36,
+	KEY_RCTRL: 0x80 + 0x1d,
+	KEY_RALT: 0x80 + 0x38,
+} as const;
+
+import { Key, matchesKey, parseKey } from "indusagi/tui";
+
+/**
+ * Map terminal key input to DOOM key codes
+ * Supports both raw terminal input and Kitty protocol sequences
+ */
+export function mapKeyToDoom(data: string): number[] {
+	// Arrow keys
+	if (matchesKey(data, Key.up)) return [DoomKeys.KEY_UPARROW];
+	if (matchesKey(data, Key.down)) return [DoomKeys.KEY_DOWNARROW];
+	if (matchesKey(data, Key.right)) return [DoomKeys.KEY_RIGHTARROW];
+	if (matchesKey(data, Key.left)) return [DoomKeys.KEY_LEFTARROW];
+
+	// WASD - check both raw char and Kitty sequences
+	if (data === "w" || matchesKey(data, "w")) return [DoomKeys.KEY_UPARROW];
+	if (data === "W" || matchesKey(data, Key.shift("w"))) return [DoomKeys.KEY_UPARROW, DoomKeys.KEY_RSHIFT];
+	if (data === "s" || matchesKey(data, "s")) return [DoomKeys.KEY_DOWNARROW];
+	if (data === "S" || matchesKey(data, Key.shift("s"))) return [DoomKeys.KEY_DOWNARROW, DoomKeys.KEY_RSHIFT];
+	if (data === "a" || matchesKey(data, "a")) return [DoomKeys.KEY_STRAFE_L];
+	if (data === "A" || matchesKey(data, Key.shift("a"))) return [DoomKeys.KEY_STRAFE_L, DoomKeys.KEY_RSHIFT];
+	if (data === "d" || matchesKey(data, "d")) return [DoomKeys.KEY_STRAFE_R];
+	if (data === "D" || matchesKey(data, Key.shift("d"))) return [DoomKeys.KEY_STRAFE_R, DoomKeys.KEY_RSHIFT];
+
+	// Fire - F key
+	if (data === "f" || data === "F" || matchesKey(data, "f") || matchesKey(data, Key.shift("f"))) {
+		return [DoomKeys.KEY_FIRE];
+	}
+
+	// Use/Open
+	if (data === " " || matchesKey(data, Key.space)) return [DoomKeys.KEY_USE];
+
+	// Menu/UI keys
+	if (matchesKey(data, Key.enter)) return [DoomKeys.KEY_ENTER];
+	if (matchesKey(data, Key.escape)) return [DoomKeys.KEY_ESCAPE];
+	if (matchesKey(data, Key.tab)) return [DoomKeys.KEY_TAB];
+	if (matchesKey(data, Key.backspace)) return [DoomKeys.KEY_BACKSPACE];
+
+	// Ctrl keys (except Ctrl+C) = fire (legacy support)
+	const parsed = parseKey(data);
+	if (parsed?.startsWith("ctrl+") && parsed !== "ctrl+c") {
+		return [DoomKeys.KEY_FIRE];
+	}
+	if (data.length === 1 && data.charCodeAt(0) < 32 && data !== "\x03") {
+		return [DoomKeys.KEY_FIRE];
+	}
+
+	// Weapon selection (0-9)
+	if (data >= "0" && data <= "9") return [data.charCodeAt(0)];
+
+	// Plus/minus for screen size
+	if (data === "+" || data === "=") return [DoomKeys.KEY_EQUALS];
+	if (data === "-") return [DoomKeys.KEY_MINUS];
+
+	// Y/N for prompts
+	if (data === "y" || data === "Y" || matchesKey(data, "y") || matchesKey(data, Key.shift("y"))) {
+		return ["y".charCodeAt(0)];
+	}
+	if (data === "n" || data === "N" || matchesKey(data, "n") || matchesKey(data, Key.shift("n"))) {
+		return ["n".charCodeAt(0)];
+	}
+
+	// Other printable characters (for cheats)
+	if (data.length === 1 && data.charCodeAt(0) >= 32) {
+		return [data.toLowerCase().charCodeAt(0)];
+	}
+
+	return [];
+}
+

package/examples/extensions/doom-overlay/index.ts

@@ -0,0 +1,74 @@
+/**
+ * DOOM Overlay Demo - Play DOOM as an overlay
+ *
+ * Usage: indusagi --extension ./examples/extensions/doom-overlay
+ *
+ * Commands:
+ *   /doom-overlay - Play DOOM in an overlay (Q to pause/exit)
+ *
+ * This demonstrates that overlays can handle real-time game rendering at 35 FPS.
+ */
+
+import type { ExtensionAPI } from "indusagi-coding-agent";
+import { DoomOverlayComponent } from "./doom-component.js";
+import { DoomEngine } from "./doom-engine.js";
+import { ensureWadFile } from "./wad-finder.js";
+
+// Persistent engine instance - survives between invocations
+let activeEngine: DoomEngine | null = null;
+let activeWadPath: string | null = null;
+
+export default function (indusagi: ExtensionAPI) {
+	indusagi.registerCommand("doom-overlay", {
+		description: "Play DOOM as an overlay. Q to pause and exit.",
+
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("DOOM requires interactive mode", "error");
+				return;
+			}
+
+			// Auto-download WAD if not present
+			ctx.ui.notify("Loading DOOM...", "info");
+			const wad = args?.trim() ? args.trim() : await ensureWadFile();
+
+			if (!wad) {
+				ctx.ui.notify("Failed to download DOOM WAD file. Check your internet connection.", "error");
+				return;
+			}
+
+			try {
+				// Reuse existing engine if same WAD, otherwise create new
+				let isResume = false;
+				if (activeEngine && activeWadPath === wad) {
+					ctx.ui.notify("Resuming DOOM...", "info");
+					isResume = true;
+				} else {
+					ctx.ui.notify(`Loading DOOM from ${wad}...`, "info");
+					activeEngine = new DoomEngine(wad);
+					await activeEngine.init();
+					activeWadPath = wad;
+				}
+
+				await ctx.ui.custom(
+					(tui, _theme, _keybindings, done) => {
+						return new DoomOverlayComponent(tui, activeEngine!, () => done(undefined), isResume);
+					},
+					{
+						overlay: true,
+						overlayOptions: {
+							width: "75%",
+							maxHeight: "95%",
+							anchor: "center",
+							margin: { top: 1 },
+						},
+					},
+				);
+			} catch (error) {
+				ctx.ui.notify(`Failed to load DOOM: ${error}`, "error");
+				activeEngine = null;
+				activeWadPath = null;
+			}
+		},
+	});
+}

package/examples/extensions/doom-overlay/wad-finder.ts

@@ -0,0 +1,51 @@
+import { existsSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Get the bundled WAD path (relative to this module)
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_WAD = join(__dirname, "doom1.wad");
+const WAD_URL = "https://distro.ibiblio.org/slitaz/sources/packages/d/doom1.wad";
+
+const DEFAULT_WAD_PATHS = ["./doom1.wad", "./DOOM1.WAD", "~/doom1.wad", "~/.doom/doom1.wad"];
+
+export function findWadFile(customPath?: string): string | null {
+	if (customPath) {
+		const resolved = resolve(customPath.replace(/^~/, process.env.HOME || ""));
+		if (existsSync(resolved)) return resolved;
+		return null;
+	}
+
+	// Check bundled WAD first
+	if (existsSync(BUNDLED_WAD)) {
+		return BUNDLED_WAD;
+	}
+
+	// Fall back to default paths
+	for (const p of DEFAULT_WAD_PATHS) {
+		const resolved = resolve(p.replace(/^~/, process.env.HOME || ""));
+		if (existsSync(resolved)) return resolved;
+	}
+
+	return null;
+}
+
+/** Download the shareware WAD if not present. Returns path or null on failure. */
+export async function ensureWadFile(): Promise<string | null> {
+	// Check if already exists
+	const existing = findWadFile();
+	if (existing) return existing;
+
+	// Download to bundled location
+	try {
+		const response = await fetch(WAD_URL);
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}`);
+		}
+		const buffer = await response.arrayBuffer();
+		writeFileSync(BUNDLED_WAD, Buffer.from(buffer));
+		return BUNDLED_WAD;
+	} catch {
+		return null;
+	}
+}

package/examples/extensions/event-bus.ts

@@ -0,0 +1,43 @@
+/**
+ * Inter-extension event bus example.
+ *
+ * Shows indusagi.events for communication between extensions. One extension
+ * can emit events that other extensions listen to.
+ *
+ * Usage: /emit [event-name] [data] - emit an event on the bus
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "indusagi-coding-agent";
+
+export default function (indusagi: ExtensionAPI) {
+	// Store ctx for use in event handler
+	let currentCtx: ExtensionContext | undefined;
+
+	indusagi.on("session_start", async (_event, ctx) => {
+		currentCtx = ctx;
+	});
+
+	// Listen for events from other extensions
+	indusagi.events.on("my:notification", (data) => {
+		const { message, from } = data as { message: string; from: string };
+		currentCtx?.ui.notify(`Event from ${from}: ${message}`, "info");
+	});
+
+	// Command to emit events (emits "my:notification" which the listener above receives)
+	indusagi.registerCommand("emit", {
+		description: "Emit my:notification event (usage: /emit message)",
+		handler: async (args, _ctx) => {
+			const message = args.trim() || "hello";
+			indusagi.events.emit("my:notification", { message, from: "/emit command" });
+			// Listener above will show the notification
+		},
+	});
+
+	// Example: emit on session start
+	indusagi.on("session_start", async () => {
+		indusagi.events.emit("my:notification", {
+			message: "Session started",
+			from: "event-bus-example",
+		});
+	});
+}

package/examples/extensions/file-trigger.ts

@@ -0,0 +1,41 @@
+/**
+ * File Trigger Extension
+ *
+ * Watches a trigger file and injects its contents into the conversation.
+ * Useful for external systems to send messages to the agent.
+ *
+ * Usage:
+ *   echo "Run the tests" > /tmp/agent-trigger.txt
+ */
+
+import * as fs from "node:fs";
+import type { ExtensionAPI } from "indusagi-coding-agent";
+
+export default function (indusagi: ExtensionAPI) {
+	indusagi.on("session_start", async (_event, ctx) => {
+		const triggerFile = "/tmp/agent-trigger.txt";
+
+		fs.watch(triggerFile, () => {
+			try {
+				const content = fs.readFileSync(triggerFile, "utf-8").trim();
+				if (content) {
+					indusagi.sendMessage(
+						{
+							customType: "file-trigger",
+							content: `External trigger: ${content}`,
+							display: true,
+						},
+						{ triggerTurn: true }, // triggerTurn - get LLM to respond
+					);
+					fs.writeFileSync(triggerFile, ""); // Clear after reading
+				}
+			} catch {
+				// File might not exist yet
+			}
+		});
+
+		if (ctx.hasUI) {
+			ctx.ui.notify(`Watching ${triggerFile}`, "info");
+		}
+	});
+}

package/examples/extensions/git-checkpoint.ts

@@ -0,0 +1,53 @@
+/**
+ * Git Checkpoint Extension
+ *
+ * Creates git stash checkpoints at each turn so /fork can restore code state.
+ * When forking, offers to restore code to that point in history.
+ */
+
+import type { ExtensionAPI } from "indusagi-coding-agent";
+
+export default function (indusagi: ExtensionAPI) {
+	const checkpoints = new Map<string, string>();
+	let currentEntryId: string | undefined;
+
+	// Track the current entry ID when user messages are saved
+	indusagi.on("tool_result", async (_event, ctx) => {
+		const leaf = ctx.sessionManager.getLeafEntry();
+		if (leaf) currentEntryId = leaf.id;
+	});
+
+	indusagi.on("turn_start", async () => {
+		// Create a git stash entry before LLM makes changes
+		const { stdout } = await indusagi.exec("git", ["stash", "create"]);
+		const ref = stdout.trim();
+		if (ref && currentEntryId) {
+			checkpoints.set(currentEntryId, ref);
+		}
+	});
+
+	indusagi.on("session_before_fork", async (event, ctx) => {
+		const ref = checkpoints.get(event.entryId);
+		if (!ref) return;
+
+		if (!ctx.hasUI) {
+			// In non-interactive mode, don't restore automatically
+			return;
+		}
+
+		const choice = await ctx.ui.select("Restore code state?", [
+			"Yes, restore code to that point",
+			"No, keep current code",
+		]);
+
+		if (choice?.startsWith("Yes")) {
+			await indusagi.exec("git", ["stash", "apply", ref]);
+			ctx.ui.notify("Code restored to checkpoint", "info");
+		}
+	});
+
+	indusagi.on("agent_end", async () => {
+		// Clear checkpoints after agent completes
+		checkpoints.clear();
+	});
+}

package/examples/extensions/handoff.ts

@@ -0,0 +1,151 @@
+/**
+ * Handoff extension - transfer context to a new focused session
+ *
+ * Instead of compacting (which is lossy), handoff extracts what matters
+ * for your next task and creates a new session with a generated prompt.
+ *
+ * Usage:
+ *   /handoff now implement this for teams as well
+ *   /handoff execute phase one of the plan
+ *   /handoff check other places that need this fix
+ *
+ * The generated prompt appears as a draft in the editor for review/editing.
+ */
+
+import { complete, type Message } from "indusagi/ai";
+import type { ExtensionAPI, SessionEntry } from "indusagi-coding-agent";
+import { BorderedLoader, convertToLlm, serializeConversation } from "indusagi-coding-agent";
+
+const SYSTEM_PROMPT = `You are a context transfer assistant. Given a conversation history and the user's goal for a new thread, generate a focused prompt that:
+
+1. Summarizes relevant context from the conversation (decisions made, approaches taken, key findings)
+2. Lists any relevant files that were discussed or modified
+3. Clearly states the next task based on the user's goal
+4. Is self-contained - the new thread should be able to proceed without the old conversation
+
+Format your response as a prompt the user can send to start the new thread. Be concise but include all necessary context. Do not include any preamble like "Here's the prompt" - just output the prompt itself.
+
+Example output format:
+## Context
+We've been working on X. Key decisions:
+- Decision 1
+- Decision 2
+
+Files involved:
+- path/to/file1.ts
+- path/to/file2.ts
+
+## Task
+[Clear description of what to do next based on user's goal]`;
+
+export default function (indusagi: ExtensionAPI) {
+	indusagi.registerCommand("handoff", {
+		description: "Transfer context to a new focused session",
+		handler: async (args, ctx) => {
+			if (!ctx.hasUI) {
+				ctx.ui.notify("handoff requires interactive mode", "error");
+				return;
+			}
+
+			if (!ctx.model) {
+				ctx.ui.notify("No model selected", "error");
+				return;
+			}
+
+			const goal = args.trim();
+			if (!goal) {
+				ctx.ui.notify("Usage: /handoff <goal for new thread>", "error");
+				return;
+			}
+
+			// Gather conversation context from current branch
+			const branch = ctx.sessionManager.getBranch();
+			const messages = branch
+				.filter((entry): entry is SessionEntry & { type: "message" } => entry.type === "message")
+				.map((entry) => entry.message);
+
+			if (messages.length === 0) {
+				ctx.ui.notify("No conversation to hand off", "error");
+				return;
+			}
+
+			// Convert to LLM format and serialize
+			const llmMessages = convertToLlm(messages);
+			const conversationText = serializeConversation(llmMessages);
+			const currentSessionFile = ctx.sessionManager.getSessionFile();
+
+			// Generate the handoff prompt with loader UI
+			const result = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+				const loader = new BorderedLoader(tui, theme, `Generating handoff prompt...`);
+				loader.onAbort = () => done(null);
+
+				const doGenerate = async () => {
+					const apiKey = await ctx.modelRegistry.getApiKey(ctx.model!);
+
+					const userMessage: Message = {
+						role: "user",
+						content: [
+							{
+								type: "text",
+								text: `## Conversation History\n\n${conversationText}\n\n## User's Goal for New Thread\n\n${goal}`,
+							},
+						],
+						timestamp: Date.now(),
+					};
+
+					const response = await complete(
+						ctx.model!,
+						{ systemPrompt: SYSTEM_PROMPT, messages: [userMessage] },
+						{ apiKey, signal: loader.signal },
+					);
+
+					if (response.stopReason === "aborted") {
+						return null;
+					}
+
+					return response.content
+						.filter((c): c is { type: "text"; text: string } => c.type === "text")
+						.map((c) => c.text)
+						.join("\n");
+				};
+
+				doGenerate()
+					.then(done)
+					.catch((err) => {
+						console.error("Handoff generation failed:", err);
+						done(null);
+					});
+
+				return loader;
+			});
+
+			if (result === null) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			// Let user edit the generated prompt
+			const editedPrompt = await ctx.ui.editor("Edit handoff prompt", result);
+
+			if (editedPrompt === undefined) {
+				ctx.ui.notify("Cancelled", "info");
+				return;
+			}
+
+			// Create new session with parent tracking
+			const newSessionResult = await ctx.newSession({
+				parentSession: currentSessionFile,
+			});
+
+			if (newSessionResult.cancelled) {
+				ctx.ui.notify("New session cancelled", "info");
+				return;
+			}
+
+			// Set the edited prompt in the main editor for submission
+			ctx.ui.setEditorText(editedPrompt);
+			ctx.ui.notify("Handoff ready. Submit when ready.", "info");
+		},
+	});
+}
+