@valni/cli-darwin-x64 0.1.2 → 0.1.4

package/runtime/examples/extensions/rainbow-editor.ts

@@ -1,7 +1,7 @@
 /**
  * Rainbow Editor - highlights "ultrathink" with animated shine effect
  *
- * Usage: pi --extension ./examples/extensions/rainbow-editor.ts
+ * Usage: valni --extension ./examples/extensions/rainbow-editor.ts
  */
 
 import { CustomEditor, type ExtensionAPI } from "@valni/cli";
@@ -81,8 +81,8 @@ class RainbowEditor extends CustomEditor {
 	}
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.on("session_start", (_event, ctx) => {
+export default function (valni: ExtensionAPI) {
+	valni.on("session_start", (_event, ctx) => {
 		ctx.ui.setEditorComponent((tui, theme, kb) => new RainbowEditor(tui, theme, kb));
 	});
 }

package/runtime/examples/extensions/reload-runtime.ts

@@ -8,10 +8,10 @@
 import type { ExtensionAPI } from "@valni/cli";
 import { Type } from "typebox";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	// Command entrypoint for reload.
 	// Treat reload as terminal for this handler.
-	pi.registerCommand("reload-runtime", {
+	valni.registerCommand("reload-runtime", {
 		description: "Reload extensions, skills, prompts, themes, and context files",
 		handler: async (_args, ctx) => {
 			await ctx.reload();
@@ -21,13 +21,13 @@ export default function (pi: ExtensionAPI) {
 
 	// LLM-callable tool. Tools get ExtensionContext, so they cannot call ctx.reload() directly.
 	// Instead, queue a follow-up user command that executes the command above.
-	pi.registerTool({
+	valni.registerTool({
 		name: "reload_runtime",
 		label: "Reload Runtime",
 		description: "Reload extensions, skills, prompts, themes, and context files",
 		parameters: Type.Object({}),
 		async execute() {
-			pi.sendUserMessage("/reload-runtime", { deliverAs: "followUp" });
+			valni.sendUserMessage("/reload-runtime", { deliverAs: "followUp" });
 			return {
 				content: [{ type: "text", text: "Queued /reload-runtime as a follow-up command." }],
 				details: {},

package/runtime/examples/extensions/rpc-demo.ts

@@ -19,31 +19,31 @@
 
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	let turnCount = 0;
 
 	// -- setTitle, setWidget, setStatus on session lifecycle --
 
-	pi.on("session_start", async (event, ctx) => {
-		ctx.ui.setTitle(event.reason === "new" ? "pi RPC Demo (new session)" : "pi RPC Demo");
+	valni.on("session_start", async (event, ctx) => {
+		ctx.ui.setTitle(event.reason === "new" ? "valni RPC Demo (new session)" : "valni RPC Demo");
 		ctx.ui.setWidget("rpc-demo", ["--- RPC Extension UI Demo ---", "Loaded and ready."]);
 		ctx.ui.setStatus("rpc-demo", `Turns: ${turnCount}`);
 	});
 
 	// -- setStatus on turn lifecycle --
 
-	pi.on("turn_start", async (_event, ctx) => {
+	valni.on("turn_start", async (_event, ctx) => {
 		turnCount++;
 		ctx.ui.setStatus("rpc-demo", `Turn ${turnCount} running...`);
 	});
 
-	pi.on("turn_end", async (_event, ctx) => {
+	valni.on("turn_end", async (_event, ctx) => {
 		ctx.ui.setStatus("rpc-demo", `Turn ${turnCount} done`);
 	});
 
 	// -- select on dangerous tool calls --
 
-	pi.on("tool_call", async (event, ctx) => {
+	valni.on("tool_call", async (event, ctx) => {
 		if (event.toolName !== "bash") return undefined;
 
 		const command = event.input.command as string;
@@ -67,7 +67,7 @@ export default function (pi: ExtensionAPI) {
 
 	// -- confirm on session clear --
 
-	pi.on("session_before_switch", async (event, ctx) => {
+	valni.on("session_before_switch", async (event, ctx) => {
 		if (event.reason !== "new") return;
 		if (!ctx.hasUI) return;
 
@@ -80,7 +80,7 @@ export default function (pi: ExtensionAPI) {
 
 	// -- input via command --
 
-	pi.registerCommand("rpc-input", {
+	valni.registerCommand("rpc-input", {
 		description: "Prompt for text input (demonstrates ctx.ui.input in RPC)",
 		handler: async (_args, ctx) => {
 			const value = await ctx.ui.input("Enter a value", "type something...");
@@ -94,7 +94,7 @@ export default function (pi: ExtensionAPI) {
 
 	// -- editor via command --
 
-	pi.registerCommand("rpc-editor", {
+	valni.registerCommand("rpc-editor", {
 		description: "Open multi-line editor (demonstrates ctx.ui.editor in RPC)",
 		handler: async (_args, ctx) => {
 			const text = await ctx.ui.editor("Edit some text", "Line 1\nLine 2\nLine 3");
@@ -108,7 +108,7 @@ export default function (pi: ExtensionAPI) {
 
 	// -- setEditorText via command --
 
-	pi.registerCommand("rpc-prefill", {
+	valni.registerCommand("rpc-prefill", {
 		description: "Prefill the input editor (demonstrates ctx.ui.setEditorText in RPC)",
 		handler: async (_args, ctx) => {
 			ctx.ui.setEditorText("This text was set by the rpc-demo extension.");

package/runtime/examples/extensions/sandbox/index.ts

@@ -10,10 +10,10 @@
  * via `tool_call` input mutation without replacing the tool.
  *
  * Config files (merged, project takes precedence):
- * - ~/.pi/agent/extensions/sandbox.json (global)
- * - <cwd>/.pi/sandbox.json (project-local)
+ * - ~/.valni/agent/extensions/sandbox.json (global)
+ * - <cwd>/.valni/sandbox.json (project-local)
  *
- * Example .pi/sandbox.json:
+ * Example .valni/sandbox.json:
  * ```json
  * {
  *   "enabled": true,
@@ -30,13 +30,13 @@
  * ```
  *
  * Usage:
- * - `pi -e ./sandbox` - sandbox enabled with default/config settings
- * - `pi -e ./sandbox --no-sandbox` - disable sandboxing
+ * - `valni -e ./sandbox` - sandbox enabled with default/config settings
+ * - `valni -e ./sandbox --no-sandbox` - disable sandboxing
  * - `/sandbox` - show current sandbox configuration
  *
  * Setup:
- * 1. Copy sandbox/ directory to ~/.pi/agent/extensions/
- * 2. Run `npm install` in ~/.pi/agent/extensions/sandbox/
+ * 1. Copy sandbox/ directory to ~/.valni/agent/extensions/
+ * 2. Run `npm install` in ~/.valni/agent/extensions/sandbox/
  *
  * Linux also requires: bubblewrap, socat, ripgrep
  */
@@ -198,8 +198,8 @@ function createSandboxedBashOps(): BashOperations {
 	};
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.registerFlag("no-sandbox", {
+export default function (valni: ExtensionAPI) {
+	valni.registerFlag("no-sandbox", {
 		description: "Disable OS-level sandboxing for bash commands",
 		type: "boolean",
 		default: false,
@@ -211,7 +211,7 @@ export default function (pi: ExtensionAPI) {
 	let sandboxEnabled = false;
 	let sandboxInitialized = false;
 
-	pi.registerTool({
+	valni.registerTool({
 		...localBash,
 		label: "bash (sandboxed)",
 		async execute(id, params, signal, onUpdate, _ctx) {
@@ -226,13 +226,13 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.on("user_bash", () => {
+	valni.on("user_bash", () => {
 		if (!sandboxEnabled || !sandboxInitialized) return;
 		return { operations: createSandboxedBashOps() };
 	});
 
-	pi.on("session_start", async (_event, ctx) => {
-		const noSandbox = pi.getFlag("no-sandbox") as boolean;
+	valni.on("session_start", async (_event, ctx) => {
+		const noSandbox = valni.getFlag("no-sandbox") as boolean;
 
 		if (noSandbox) {
 			sandboxEnabled = false;
@@ -284,7 +284,7 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
-	pi.on("session_shutdown", async () => {
+	valni.on("session_shutdown", async () => {
 		if (sandboxInitialized) {
 			try {
 				await SandboxManager.reset();
@@ -294,7 +294,7 @@ export default function (pi: ExtensionAPI) {
 		}
 	});
 
-	pi.registerCommand("sandbox", {
+	valni.registerCommand("sandbox", {
 		description: "Show sandbox configuration",
 		handler: async (_args, ctx) => {
 			if (!sandboxEnabled) {

package/runtime/examples/extensions/sandbox/package-lock.json

@@ -1,12 +1,12 @@
 {
-	"name": "pi-extension-sandbox",
-	"version": "1.10.10",
+	"name": "valni-extension-sandbox",
+	"version": "1.10.11",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
-			"name": "pi-extension-sandbox",
-			"version": "1.10.10",
+			"name": "valni-extension-sandbox",
+			"version": "1.10.11",
 			"dependencies": {
 				"@anthropic-ai/sandbox-runtime": "^0.0.26"
 			}

package/runtime/examples/extensions/sandbox/package.json

@@ -1,14 +1,14 @@
 {
-	"name": "pi-extension-sandbox",
+	"name": "valni-extension-sandbox",
 	"private": true,
-	"version": "1.10.10",
+	"version": "1.10.11",
 	"type": "module",
 	"scripts": {
 		"clean": "echo 'nothing to clean'",
 		"build": "echo 'nothing to build'",
 		"check": "echo 'nothing to check'"
 	},
-	"pi": {
+	"valni": {
 		"extensions": [
 			"./index.ts"
 		]

package/runtime/examples/extensions/send-user-message.ts

@@ -1,8 +1,8 @@
 /**
  * Send User Message Example
  *
- * Demonstrates pi.sendUserMessage() for sending user messages from extensions.
- * Unlike pi.sendMessage() which sends custom messages, sendUserMessage() sends
+ * Demonstrates valni.sendUserMessage() for sending user messages from extensions.
+ * Unlike valni.sendMessage() which sends custom messages, sendUserMessage() sends
  * actual user messages that appear in the conversation as if typed by the user.
  *
  * Usage:
@@ -13,9 +13,9 @@
 
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	// Simple command that sends a user message
-	pi.registerCommand("ask", {
+	valni.registerCommand("ask", {
 		description: "Send a user message to the agent",
 		handler: async (args, ctx) => {
 			if (!args.trim()) {
@@ -30,12 +30,12 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
-			pi.sendUserMessage(args);
+			valni.sendUserMessage(args);
 		},
 	});
 
 	// Command that steers the agent mid-conversation
-	pi.registerCommand("steer", {
+	valni.registerCommand("steer", {
 		description: "Send a steering message (interrupts current processing)",
 		handler: async (args, ctx) => {
 			if (!args.trim()) {
@@ -45,16 +45,16 @@ export default function (pi: ExtensionAPI) {
 
 			if (ctx.isIdle()) {
 				// Not streaming, just send normally
-				pi.sendUserMessage(args);
+				valni.sendUserMessage(args);
 			} else {
 				// Streaming - use steer to interrupt
-				pi.sendUserMessage(args, { deliverAs: "steer" });
+				valni.sendUserMessage(args, { deliverAs: "steer" });
 			}
 		},
 	});
 
 	// Command that queues a follow-up message
-	pi.registerCommand("followup", {
+	valni.registerCommand("followup", {
 		description: "Queue a follow-up message (waits for current processing)",
 		handler: async (args, ctx) => {
 			if (!args.trim()) {
@@ -64,17 +64,17 @@ export default function (pi: ExtensionAPI) {
 
 			if (ctx.isIdle()) {
 				// Not streaming, just send normally
-				pi.sendUserMessage(args);
+				valni.sendUserMessage(args);
 			} else {
 				// Streaming - queue as follow-up
-				pi.sendUserMessage(args, { deliverAs: "followUp" });
+				valni.sendUserMessage(args, { deliverAs: "followUp" });
 				ctx.ui.notify("Follow-up queued", "info");
 			}
 		},
 	});
 
 	// Example with content array (text + images would go here)
-	pi.registerCommand("askwith", {
+	valni.registerCommand("askwith", {
 		description: "Send a user message with structured content",
 		handler: async (args, ctx) => {
 			if (!args.trim()) {
@@ -88,7 +88,7 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			// sendUserMessage accepts string or (TextContent | ImageContent)[]
-			pi.sendUserMessage([
+			valni.sendUserMessage([
 				{ type: "text", text: `User request: ${args}` },
 				{ type: "text", text: "Please respond concisely." },
 			]);

package/runtime/examples/extensions/session-name.ts

@@ -9,17 +9,17 @@
 
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
-	pi.registerCommand("session-name", {
+export default function (valni: ExtensionAPI) {
+	valni.registerCommand("session-name", {
 		description: "Set or show session name (usage: /session-name [new name])",
 		handler: async (args, ctx) => {
 			const name = args.trim();
 
 			if (name) {
-				pi.setSessionName(name);
+				valni.setSessionName(name);
 				ctx.ui.notify(`Session named: ${name}`, "info");
 			} else {
-				const current = pi.getSessionName();
+				const current = valni.getSessionName();
 				ctx.ui.notify(current ? `Session: ${current}` : "No session name set", "info");
 			}
 		},

package/runtime/examples/extensions/shutdown-command.ts

@@ -2,26 +2,26 @@
  * Shutdown Command Extension
  *
  * Adds a /quit command that allows extensions to trigger clean shutdown.
- * Demonstrates how extensions can use ctx.shutdown() to exit pi cleanly.
+ * Demonstrates how extensions can use ctx.shutdown() to exit valni cleanly.
  */
 
 import type { ExtensionAPI } from "@valni/cli";
 import { Type } from "typebox";
 
-export default function (pi: ExtensionAPI) {
-	// Register a /quit command that cleanly exits pi
-	pi.registerCommand("quit", {
-		description: "Exit pi cleanly",
+export default function (valni: ExtensionAPI) {
+	// Register a /quit command that cleanly exits valni
+	valni.registerCommand("quit", {
+		description: "Exit valni cleanly",
 		handler: async (_args, ctx) => {
 			ctx.shutdown();
 		},
 	});
 
 	// You can also create a tool that shuts down after completing work
-	pi.registerTool({
+	valni.registerTool({
 		name: "finish_and_exit",
 		label: "Finish and Exit",
-		description: "Complete a task and exit pi",
+		description: "Complete a task and exit valni",
 		parameters: Type.Object({}),
 		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
 			// Do any final work here...
@@ -37,10 +37,10 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// You could also create a more complex tool with parameters
-	pi.registerTool({
+	valni.registerTool({
 		name: "deploy_and_exit",
 		label: "Deploy and Exit",
-		description: "Deploy the application and exit pi",
+		description: "Deploy the application and exit valni",
 		parameters: Type.Object({
 			environment: Type.String({ description: "Target environment (e.g., production, staging)" }),
 		}),
@@ -48,7 +48,7 @@ export default function (pi: ExtensionAPI) {
 			onUpdate?.({ content: [{ type: "text", text: `Deploying to ${params.environment}...` }], details: {} });
 
 			// Example deployment logic
-			// const result = await pi.exec("npm", ["run", "deploy", params.environment], { signal });
+			// const result = await valni.exec("npm", ["run", "deploy", params.environment], { signal });
 
 			// On success, request graceful shutdown
 			onUpdate?.({ content: [{ type: "text", text: "Deployment complete, exiting..." }], details: {} });

package/runtime/examples/extensions/snake.ts

@@ -306,8 +306,8 @@ class SnakeComponent {
 
 const SNAKE_SAVE_TYPE = "snake-save";
 
-export default function (pi: ExtensionAPI) {
-	pi.registerCommand("snake", {
+export default function (valni: ExtensionAPI) {
+	valni.registerCommand("snake", {
 		description: "Play Snake!",
 
 		handler: async (_args, ctx) => {
@@ -333,7 +333,7 @@ export default function (pi: ExtensionAPI) {
 					() => done(undefined),
 					(state) => {
 						// Save or clear state
-						pi.appendEntry(SNAKE_SAVE_TYPE, state);
+						valni.appendEntry(SNAKE_SAVE_TYPE, state);
 					},
 					savedState,
 				);

package/runtime/examples/extensions/space-invaders.ts

@@ -524,8 +524,8 @@ class SpaceInvadersComponent {
 
 const INVADERS_SAVE_TYPE = "space-invaders-save";
 
-export default function (pi: ExtensionAPI) {
-	pi.registerCommand("invaders", {
+export default function (valni: ExtensionAPI) {
+	valni.registerCommand("invaders", {
 		description: "Play Space Invaders!",
 
 		handler: async (_args, ctx) => {
@@ -550,7 +550,7 @@ export default function (pi: ExtensionAPI) {
 					tui,
 					() => done(undefined),
 					(state) => {
-						pi.appendEntry(INVADERS_SAVE_TYPE, state);
+						valni.appendEntry(INVADERS_SAVE_TYPE, state);
 					},
 					savedState,
 				);

package/runtime/examples/extensions/ssh.ts

@@ -5,8 +5,8 @@
  * When --ssh is provided, read/write/edit/bash run on the remote.
  *
  * Usage:
- *   pi -e ./ssh.ts --ssh user@host
- *   pi -e ./ssh.ts --ssh user@host:/remote/path
+ *   valni -e ./ssh.ts --ssh user@host
+ *   valni -e ./ssh.ts --ssh user@host:/remote/path
  *
  * Requirements:
  *   - SSH key-based auth (no password prompts)
@@ -111,8 +111,8 @@ function createRemoteBashOps(remote: string, remoteCwd: string, localCwd: string
 	};
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.registerFlag("ssh", { description: "SSH remote: user@host or user@host:/path", type: "string" });
+export default function (valni: ExtensionAPI) {
+	valni.registerFlag("ssh", { description: "SSH remote: user@host or user@host:/path", type: "string" });
 
 	const localCwd = process.cwd();
 	const localRead = createReadTool(localCwd);
@@ -125,7 +125,7 @@ export default function (pi: ExtensionAPI) {
 
 	const getSsh = () => resolvedSsh;
 
-	pi.registerTool({
+	valni.registerTool({
 		...localRead,
 		async execute(id, params, signal, onUpdate, _ctx) {
 			const ssh = getSsh();
@@ -139,7 +139,7 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerTool({
+	valni.registerTool({
 		...localWrite,
 		async execute(id, params, signal, onUpdate, _ctx) {
 			const ssh = getSsh();
@@ -153,7 +153,7 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerTool({
+	valni.registerTool({
 		...localEdit,
 		async execute(id, params, signal, onUpdate, _ctx) {
 			const ssh = getSsh();
@@ -167,7 +167,7 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerTool({
+	valni.registerTool({
 		...localBash,
 		async execute(id, params, signal, onUpdate, _ctx) {
 			const ssh = getSsh();
@@ -181,9 +181,9 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.on("session_start", async (_event, ctx) => {
+	valni.on("session_start", async (_event, ctx) => {
 		// Resolve SSH config now that CLI flags are available
-		const arg = pi.getFlag("ssh") as string | undefined;
+		const arg = valni.getFlag("ssh") as string | undefined;
 		if (arg) {
 			if (arg.includes(":")) {
 				const [remote, path] = arg.split(":");
@@ -200,14 +200,14 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Handle user ! commands via SSH
-	pi.on("user_bash", (_event) => {
+	valni.on("user_bash", (_event) => {
 		const ssh = getSsh();
 		if (!ssh) return; // No SSH, use local execution
 		return { operations: createRemoteBashOps(ssh.remote, ssh.remoteCwd, localCwd) };
 	});
 
 	// Replace local cwd with remote cwd in system prompt
-	pi.on("before_agent_start", async (event) => {
+	valni.on("before_agent_start", async (event) => {
 		const ssh = getSsh();
 		if (ssh) {
 			const modified = event.systemPrompt.replace(

package/runtime/examples/extensions/status-line.ts

@@ -7,15 +7,15 @@
 
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	let turnCount = 0;
 
-	pi.on("session_start", async (_event, ctx) => {
+	valni.on("session_start", async (_event, ctx) => {
 		const theme = ctx.ui.theme;
 		ctx.ui.setStatus("status-demo", theme.fg("dim", "Ready"));
 	});
 
-	pi.on("turn_start", async (_event, ctx) => {
+	valni.on("turn_start", async (_event, ctx) => {
 		turnCount++;
 		const theme = ctx.ui.theme;
 		const spinner = theme.fg("accent", "●");
@@ -23,7 +23,7 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.setStatus("status-demo", spinner + text);
 	});
 
-	pi.on("turn_end", async (_event, ctx) => {
+	valni.on("turn_end", async (_event, ctx) => {
 		const theme = ctx.ui.theme;
 		const check = theme.fg("success", "✓");
 		const text = theme.fg("dim", ` Turn ${turnCount} complete`);

package/runtime/examples/extensions/structured-output.ts

@@ -60,6 +60,6 @@ const structuredOutputTool = defineTool({
 	},
 });
 
-export default function (pi: ExtensionAPI) {
-	pi.registerTool(structuredOutputTool);
+export default function (valni: ExtensionAPI) {
+	valni.registerTool(structuredOutputTool);
 }

package/runtime/examples/extensions/subagent/index.ts

@@ -1,7 +1,7 @@
 /**
  * Subagent Tool - Delegate tasks to specialized agents
  *
- * Spawns a separate `pi` process for each subagent invocation,
+ * Spawns a separate `valni` process for each subagent invocation,
  * giving it an isolated context window.
  *
  * Supports three modes:
@@ -231,7 +231,7 @@ async function mapWithConcurrencyLimit<TIn, TOut>(
 }
 
 async function writePromptToTempFile(agentName: string, prompt: string): Promise<{ dir: string; filePath: string }> {
-	const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pi-subagent-"));
+	const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "valni-subagent-"));
 	const safeName = agentName.replace(/[^\w.-]+/g, "_");
 	const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
 	await withFileMutationQueue(filePath, async () => {
@@ -253,7 +253,7 @@ function getPiInvocation(args: string[]): { command: string; args: string[] } {
 		return { command: process.execPath, args };
 	}
 
-	return { command: "pi", args };
+	return { command: "valni", args };
 }
 
 type OnUpdateCallback = (partial: AgentToolResult<SubagentDetails>) => void;
@@ -451,8 +451,8 @@ const SubagentParams = Type.Object({
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process (single mode)" })),
 });
 
-export default function (pi: ExtensionAPI) {
-	pi.registerTool({
+export default function (valni: ExtensionAPI) {
+	valni.registerTool({
 		name: "subagent",
 		label: "Subagent",
 		description: [

package/runtime/examples/extensions/system-prompt-header.ts

@@ -5,13 +5,13 @@
  */
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
-	pi.on("agent_start", (_event, ctx) => {
+export default function (valni: ExtensionAPI) {
+	valni.on("agent_start", (_event, ctx) => {
 		const prompt = ctx.getSystemPrompt();
 		ctx.ui.setStatus("system-prompt", `System: ${prompt.length} chars`);
 	});
 
-	pi.on("session_shutdown", (_event, ctx) => {
+	valni.on("session_shutdown", (_event, ctx) => {
 		ctx.ui.setStatus("system-prompt", undefined);
 	});
 }