@valni/cli-darwin-x64 0.1.2 → 0.1.4

package/runtime/examples/extensions/tic-tac-toe.ts

@@ -655,9 +655,9 @@ function getBoardDetails(): BoardDetails {
 	};
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
-	pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
+export default function (valni: ExtensionAPI) {
+	valni.on("session_start", async (_event, ctx) => reconstructState(ctx));
+	valni.on("session_tree", async (_event, ctx) => reconstructState(ctx));
 
 	// Sent once per game at end-of-game. The custom renderer paints the banner;
 	// `content` is a plain-text fallback for any non-TUI consumer and for the
@@ -671,7 +671,7 @@ export default function (pi: ExtensionAPI) {
 					: gameState.status === "draw"
 						? "Draw"
 						: "Game over";
-		pi.sendMessage({
+		valni.sendMessage({
 			customType: GAME_OVER_MESSAGE_TYPE,
 			content: `Game over: ${label}.`,
 			display: true,
@@ -682,7 +682,7 @@ export default function (pi: ExtensionAPI) {
 	// -----------------------------------------------------------------------
 	// Custom message renderer for user move messages
 	// -----------------------------------------------------------------------
-	pi.registerMessageRenderer(MOVE_MESSAGE_TYPE, (message, { expanded }, theme) => {
+	valni.registerMessageRenderer(MOVE_MESSAGE_TYPE, (message, { expanded }, theme) => {
 		const details = message.details as BoardDetails | undefined;
 		const turnLabel =
 			details?.currentTurn === "O"
@@ -695,7 +695,7 @@ export default function (pi: ExtensionAPI) {
 	// -----------------------------------------------------------------------
 	// Custom message renderer for game-over messages
 	// -----------------------------------------------------------------------
-	pi.registerMessageRenderer(GAME_OVER_MESSAGE_TYPE, (message, _options, theme) => {
+	valni.registerMessageRenderer(GAME_OVER_MESSAGE_TYPE, (message, _options, theme) => {
 		const details = message.details as BoardDetails | undefined;
 		const status = (details?.status ?? "draw") as GameStatus;
 		return new GameOverMessageComponent(status, details, theme);
@@ -704,7 +704,7 @@ export default function (pi: ExtensionAPI) {
 	// -----------------------------------------------------------------------
 	// before_agent_start - inject game instructions each turn
 	// -----------------------------------------------------------------------
-	pi.on("before_agent_start", async (event) => {
+	valni.on("before_agent_start", async (event) => {
 		if (!gameActive) return undefined;
 
 		const instructions = `
@@ -775,7 +775,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 	// -----------------------------------------------------------------------
 	// /tic-tac-toe command
 	// -----------------------------------------------------------------------
-	pi.registerCommand("tic-tac-toe", {
+	valni.registerCommand("tic-tac-toe", {
 		description: "Play tic-tac-toe against the agent",
 
 		handler: async (_args, ctx) => {
@@ -789,7 +789,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 				gameState = createInitialState();
 			}
 			gameActive = true;
-			pi.setSessionName("Tic-Tac-Toe");
+			valni.setSessionName("Tic-Tac-Toe");
 
 			await ctx.ui.custom<void>((tui, _theme, _kb, done) => {
 				component = new TicTacToeComponent(
@@ -806,7 +806,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 							gameState.currentTurn = gameState.agentMark;
 						}
 						component?.updateState(gameState);
-						pi.appendEntry(SAVE_TYPE, getBoardDetails());
+						valni.appendEntry(SAVE_TYPE, getBoardDetails());
 
 						if (gameState.status === "playing") {
 							// IMPORTANT: user play does NOT touch the agent cursor.
@@ -816,7 +816,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 								gameState.agentCursorRow,
 								gameState.agentCursorCol,
 							);
-							pi.sendMessage(
+							valni.sendMessage(
 								{
 									customType: MOVE_MESSAGE_TYPE,
 									content:
@@ -856,7 +856,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 		play: 0,
 	};
 
-	pi.registerTool({
+	valni.registerTool({
 		name: "tic_tac_toe",
 		label: "Tic-Tac-Toe",
 		description:
@@ -910,7 +910,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 						// Do NOT reset the cursor on failure. The agent can retry
 						// from the cursor's current position.
 						component?.updateState(gameState);
-						pi.appendEntry(SAVE_TYPE, getBoardDetails());
+						valni.appendEntry(SAVE_TYPE, getBoardDetails());
 						throw new TicTacToeError(
 							`Cell (${r},${c}) is already ${gameState.board[r][c]}. Your cursor is still at (${r},${c}). Move to an empty cell and retry play.`,
 						);
@@ -939,7 +939,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 			}
 
 			component?.updateState(gameState);
-			pi.appendEntry(SAVE_TYPE, getBoardDetails());
+			valni.appendEntry(SAVE_TYPE, getBoardDetails());
 
 			return {
 				content: [{ type: "text", text: result }],
@@ -969,7 +969,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 	// -----------------------------------------------------------------------
 	// tic_tac_toe_see_board tool - inspect board + agent cursor.
 	// -----------------------------------------------------------------------
-	pi.registerTool({
+	valni.registerTool({
 		name: "tic_tac_toe_see_board",
 		label: "See Board",
 		description:

package/runtime/examples/extensions/timed-confirm.ts

@@ -9,9 +9,9 @@
 
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	// Simple approach: use timeout option (recommended)
-	pi.registerCommand("timed", {
+	valni.registerCommand("timed", {
 		description: "Show a timed confirmation dialog (auto-cancels in 5s with countdown)",
 		handler: async (_args, ctx) => {
 			const confirmed = await ctx.ui.confirm(
@@ -28,7 +28,7 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerCommand("timed-select", {
+	valni.registerCommand("timed-select", {
 		description: "Show a timed select dialog (auto-cancels in 10s with countdown)",
 		handler: async (_args, ctx) => {
 			const choice = await ctx.ui.select("Pick an option", ["Option A", "Option B", "Option C"], { timeout: 10000 });
@@ -42,7 +42,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Manual approach: use AbortSignal for more control
-	pi.registerCommand("timed-signal", {
+	valni.registerCommand("timed-signal", {
 		description: "Show a timed confirm using AbortSignal (manual approach)",
 		handler: async (_args, ctx) => {
 			const controller = new AbortController();

package/runtime/examples/extensions/titlebar-spinner.ts

@@ -5,7 +5,7 @@
  * Uses `ctx.ui.setTitle()` to update the terminal title via the extension API.
  *
  * Usage:
- *   pi --extension examples/extensions/titlebar-spinner.ts
+ *   valni --extension examples/extensions/titlebar-spinner.ts
  */
 
 import path from "node:path";
@@ -13,13 +13,13 @@ import type { ExtensionAPI, ExtensionContext } from "@valni/cli";
 
 const BRAILLE_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
-function getBaseTitle(pi: ExtensionAPI): string {
+function getBaseTitle(valni: ExtensionAPI): string {
 	const cwd = path.basename(process.cwd());
-	const session = pi.getSessionName();
-	return session ? `π - ${session} - ${cwd}` : `π - ${cwd}`;
+	const session = valni.getSessionName();
+	return session ? `valni - ${session} - ${cwd}` : `valni - ${cwd}`;
 }
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	let timer: ReturnType<typeof setInterval> | null = null;
 	let frameIndex = 0;
 
@@ -29,7 +29,7 @@ export default function (pi: ExtensionAPI) {
 			timer = null;
 		}
 		frameIndex = 0;
-		ctx.ui.setTitle(getBaseTitle(pi));
+		ctx.ui.setTitle(getBaseTitle(valni));
 	}
 
 	function startAnimation(ctx: ExtensionContext) {
@@ -37,22 +37,22 @@ export default function (pi: ExtensionAPI) {
 		timer = setInterval(() => {
 			const frame = BRAILLE_FRAMES[frameIndex % BRAILLE_FRAMES.length];
 			const cwd = path.basename(process.cwd());
-			const session = pi.getSessionName();
-			const title = session ? `${frame} π - ${session} - ${cwd}` : `${frame} π - ${cwd}`;
+			const session = valni.getSessionName();
+			const title = session ? `${frame} valni - ${session} - ${cwd}` : `${frame} valni - ${cwd}`;
 			ctx.ui.setTitle(title);
 			frameIndex++;
 		}, 80);
 	}
 
-	pi.on("agent_start", async (_event, ctx) => {
+	valni.on("agent_start", async (_event, ctx) => {
 		startAnimation(ctx);
 	});
 
-	pi.on("agent_end", async (_event, ctx) => {
+	valni.on("agent_end", async (_event, ctx) => {
 		stopAnimation(ctx);
 	});
 
-	pi.on("session_shutdown", async (_event, ctx) => {
+	valni.on("session_shutdown", async (_event, ctx) => {
 		stopAnimation(ctx);
 	});
 }

package/runtime/examples/extensions/todo.ts

@@ -102,7 +102,7 @@ class TodoListComponent {
 	}
 }
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	// In-memory state (reconstructed from session on load)
 	let todos: Todo[] = [];
 	let nextId = 1;
@@ -129,11 +129,11 @@ export default function (pi: ExtensionAPI) {
 	};
 
 	// Reconstruct state on session events
-	pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
-	pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
+	valni.on("session_start", async (_event, ctx) => reconstructState(ctx));
+	valni.on("session_tree", async (_event, ctx) => reconstructState(ctx));
 
 	// Register the todo tool for the LLM
-	pi.registerTool({
+	valni.registerTool({
 		name: "todo",
 		label: "Todo",
 		description: "Manage a todo list. Actions: list, add (text), toggle (id), clear",
@@ -281,7 +281,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Register the /todos command for users
-	pi.registerCommand("todos", {
+	valni.registerCommand("todos", {
 		description: "Show all todos on the current branch",
 		handler: async (_args, ctx) => {
 			if (ctx.mode !== "tui") {

package/runtime/examples/extensions/tool-override.ts

@@ -5,7 +5,7 @@
  * This is useful for:
  * - Adding logging or auditing to tool calls
  * - Implementing access control or sandboxing
- * - Routing tool calls to remote systems (e.g., pi-ssh-remote)
+ * - Routing tool calls to remote systems (e.g., valni-ssh-remote)
  * - Modifying tool behavior for specific workflows
  *
  * This example overrides the `read` tool to:
@@ -17,7 +17,7 @@
  * is used automatically (syntax highlighting, line numbers, truncation warnings).
  *
  * Usage:
- *   pi -e ./tool-override.ts
+ *   valni -e ./tool-override.ts
  */
 
 import type { TextContent } from "@valni/ai";
@@ -65,8 +65,8 @@ const readSchema = Type.Object({
 	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
 });
 
-export default function (pi: ExtensionAPI) {
-	pi.registerTool({
+export default function (valni: ExtensionAPI) {
+	valni.registerTool({
 		name: "read", // Same name as built-in - this will override it
 		label: "read (audited)",
 		description:
@@ -129,7 +129,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Also register a command to view the access log
-	pi.registerCommand("read-log", {
+	valni.registerCommand("read-log", {
 		description: "View the file access log",
 		handler: async (_args, ctx) => {
 			try {

package/runtime/examples/extensions/tools.ts

@@ -5,7 +5,7 @@
  * Tool selection persists across session reloads and respects branch navigation.
  *
  * Usage:
- * 1. Copy this file to ~/.pi/agent/extensions/ or your project's .pi/extensions/
+ * 1. Copy this file to ~/.valni/agent/extensions/ or your project's .valni/extensions/
  * 2. Use /tools to open the tool selector
  */
 
@@ -18,26 +18,26 @@ interface ToolsState {
 	enabledTools: string[];
 }
 
-export default function toolsExtension(pi: ExtensionAPI) {
+export default function toolsExtension(valni: ExtensionAPI) {
 	// Track enabled tools
 	let enabledTools: Set<string> = new Set();
 	let allTools: ToolInfo[] = [];
 
 	// Persist current state
 	function persistState() {
-		pi.appendEntry<ToolsState>("tools-config", {
+		valni.appendEntry<ToolsState>("tools-config", {
 			enabledTools: Array.from(enabledTools),
 		});
 	}
 
 	// Apply current tool selection
 	function applyTools() {
-		pi.setActiveTools(Array.from(enabledTools));
+		valni.setActiveTools(Array.from(enabledTools));
 	}
 
 	// Find the last tools-config entry in the current branch
 	function restoreFromBranch(ctx: ExtensionContext) {
-		allTools = pi.getAllTools();
+		allTools = valni.getAllTools();
 
 		// Get entries in current branch only
 		const branchEntries = ctx.sessionManager.getBranch();
@@ -59,12 +59,12 @@ export default function toolsExtension(pi: ExtensionAPI) {
 			applyTools();
 		} else {
 			// No saved state - sync with currently active tools
-			enabledTools = new Set(pi.getActiveTools());
+			enabledTools = new Set(valni.getActiveTools());
 		}
 	}
 
 	// Register /tools command
-	pi.registerCommand("tools", {
+	valni.registerCommand("tools", {
 		description: "Enable/disable tools",
 		handler: async (_args, ctx) => {
 			if (ctx.mode !== "tui") {
@@ -73,7 +73,7 @@ export default function toolsExtension(pi: ExtensionAPI) {
 			}
 
 			// Refresh tool list
-			allTools = pi.getAllTools();
+			allTools = valni.getAllTools();
 
 			await ctx.ui.custom((tui, theme, _kb, done) => {
 				// Build settings items for each tool
@@ -135,12 +135,12 @@ export default function toolsExtension(pi: ExtensionAPI) {
 	});
 
 	// Restore state on session start
-	pi.on("session_start", async (_event, ctx) => {
+	valni.on("session_start", async (_event, ctx) => {
 		restoreFromBranch(ctx);
 	});
 
 	// Restore state when navigating the session tree
-	pi.on("session_tree", async (_event, ctx) => {
+	valni.on("session_tree", async (_event, ctx) => {
 		restoreFromBranch(ctx);
 	});
 }

package/runtime/examples/extensions/trigger-compact.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI, ExtensionContext } from "@valni/cli";
 
 const COMPACT_THRESHOLD_TOKENS = 100_000;
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	let previousTokens: number | null | undefined;
 
 	const triggerCompaction = (ctx: ExtensionContext, customInstructions?: string) => {
@@ -24,7 +24,7 @@ export default function (pi: ExtensionAPI) {
 		});
 	};
 
-	pi.on("turn_end", (_event, ctx) => {
+	valni.on("turn_end", (_event, ctx) => {
 		const usage = ctx.getContextUsage();
 		const currentTokens = usage?.tokens ?? null;
 		if (currentTokens === null) {
@@ -40,7 +40,7 @@ export default function (pi: ExtensionAPI) {
 		triggerCompaction(ctx);
 	});
 
-	pi.registerCommand("trigger-compact", {
+	valni.registerCommand("trigger-compact", {
 		description: "Trigger compaction immediately",
 		handler: async (args, ctx) => {
 			const instructions = args.trim() || undefined;

package/runtime/examples/extensions/truncated-tool.ts

@@ -45,8 +45,8 @@ interface RgDetails {
 	fullOutputPath?: string;
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.registerTool({
+export default function (valni: ExtensionAPI) {
+	valni.registerTool({
 		name: "rg",
 		label: "ripgrep",
 		// Document the truncation limits in the tool description so the LLM knows
@@ -109,7 +109,7 @@ export default function (pi: ExtensionAPI) {
 
 			if (truncation.truncated) {
 				// Save full output to a temp file so LLM can access it if needed
-				const tempDir = await mkdtemp(join(tmpdir(), "pi-rg-"));
+				const tempDir = await mkdtemp(join(tmpdir(), "valni-rg-"));
 				const tempFile = join(tempDir, "output.txt");
 				await withFileMutationQueue(tempFile, async () => {
 					await writeFile(tempFile, output, "utf8");

package/runtime/examples/extensions/widget-placement.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function widgetPlacementExtension(pi: ExtensionAPI) {
-	pi.on("session_start", (_event, ctx) => {
+export default function widgetPlacementExtension(valni: ExtensionAPI) {
+	valni.on("session_start", (_event, ctx) => {
 		if (!ctx.hasUI) return;
 		ctx.ui.setWidget("widget-above", ["Above editor widget"]);
 		ctx.ui.setWidget("widget-below", ["Below editor widget"], { placement: "belowEditor" });

package/runtime/examples/extensions/with-deps/index.ts

@@ -9,9 +9,9 @@ import type { ExtensionAPI } from "@valni/cli";
 import ms from "ms";
 import { Type } from "typebox";
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	// Register a tool that uses ms
-	pi.registerTool({
+	valni.registerTool({
 		name: "parse_duration",
 		label: "Parse Duration",
 		description: "Parse a human-readable duration string (e.g., '2 days', '1h', '5m') to milliseconds",

package/runtime/examples/extensions/with-deps/package-lock.json

@@ -1,12 +1,12 @@
 {
-  "name": "pi-extension-with-deps",
-  "version": "0.80.10",
+  "name": "valni-extension-with-deps",
+  "version": "0.80.11",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "pi-extension-with-deps",
-      "version": "0.80.10",
+      "name": "valni-extension-with-deps",
+      "version": "0.80.11",
       "dependencies": {
         "ms": "^2.1.3"
       },

package/runtime/examples/extensions/with-deps/package.json

@@ -1,14 +1,14 @@
 {
-  "name": "pi-extension-with-deps",
+  "name": "valni-extension-with-deps",
   "private": true,
-  "version": "0.80.10",
+  "version": "0.80.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/working-indicator.ts

@@ -2,10 +2,10 @@
  * Working Indicator Extension
  *
  * Demonstrates `ctx.ui.setWorkingIndicator()` for customizing the inline
- * working indicator shown while pi is streaming a response.
+ * working indicator shown while valni is streaming a response.
  *
  * Usage:
- *   pi --extension examples/extensions/working-indicator.ts
+ *   valni --extension examples/extensions/working-indicator.ts
  *
  * Commands:
  *   /working-indicator           Show current mode
@@ -13,7 +13,7 @@
  *   /working-indicator pulse     Use a custom animated indicator
  *   /working-indicator none      Hide the indicator entirely
  *   /working-indicator spinner   Restore an animated spinner
- *   /working-indicator reset     Restore pi's default spinner
+ *   /working-indicator reset     Restore valni's default spinner
  */
 
 import type { ExtensionAPI, ExtensionContext, WorkingIndicatorOptions } from "@valni/cli";
@@ -79,11 +79,11 @@ function describeMode(mode: WorkingIndicatorMode): string {
 		case "spinner":
 			return "custom spinner";
 		case "default":
-			return "pi default spinner";
+			return "valni default spinner";
 	}
 }
 
-export default function (pi: ExtensionAPI) {
+export default function (valni: ExtensionAPI) {
 	let mode: WorkingIndicatorMode = "spinner";
 
 	const applyIndicator = (ctx: ExtensionContext) => {
@@ -91,11 +91,11 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.setStatus("working-indicator", ctx.ui.theme.fg("dim", `Indicator: ${describeMode(mode)}`));
 	};
 
-	pi.on("session_start", async (_event, ctx) => {
+	valni.on("session_start", async (_event, ctx) => {
 		applyIndicator(ctx);
 	});
 
-	pi.registerCommand("working-indicator", {
+	valni.registerCommand("working-indicator", {
 		description: "Set the streaming working indicator: dot, pulse, none, spinner, or reset.",
 		handler: async (args, ctx) => {
 			const nextMode = args.trim().toLowerCase();

package/runtime/examples/extensions/working-message-test.ts

@@ -5,7 +5,7 @@
  * verify they survive across loader recreations (e.g. between agent turns).
  *
  * Usage:
- *   pi --extension examples/extensions/working-message-test.ts
+ *   valni --extension examples/extensions/working-message-test.ts
  *
  * Then send a few messages in interactive mode. The working message should
  * stay "Working... (custom)" with a brown dot indicator every time the
@@ -17,8 +17,8 @@ import type { ExtensionAPI } from "@valni/cli";
 const CUSTOM_MESSAGE = "\x1b[38;2;155;86;63mWorking... (custom)\x1b[39m";
 const CUSTOM_INDICATOR = { frames: ["\x1b[38;2;155;86;63m●\x1b[39m"] };
 
-export default function (pi: ExtensionAPI) {
-	pi.on("session_start", async (_event, ctx) => {
+export default function (valni: ExtensionAPI) {
+	valni.on("session_start", async (_event, ctx) => {
 		ctx.ui.setWorkingMessage(CUSTOM_MESSAGE);
 		ctx.ui.setWorkingIndicator(CUSTOM_INDICATOR);
 	});

package/runtime/examples/sdk/01-minimal.ts

@@ -2,7 +2,7 @@
  * Minimal SDK Usage
  *
  * Uses all defaults: discovers skills, extensions, tools, context files
- * from cwd and ~/.pi/agent. Model chosen from settings or first available.
+ * from cwd and ~/.valni/agent. Model chosen from settings or first available.
  */
 
 import { createAgentSession } from "@valni/cli";

package/runtime/examples/sdk/03-custom-prompt.ts

@@ -15,7 +15,7 @@ const loader1 = new DefaultResourceLoader({
 	agentDir,
 	systemPromptOverride: () => `You are a helpful assistant that speaks like a pirate.
 Always end responses with "Arrr!"`,
-	// Needed to avoid DefaultResourceLoader appending APPEND_SYSTEM.md from ~/.pi/agent or <cwd>/.pi.
+	// Needed to avoid DefaultResourceLoader appending APPEND_SYSTEM.md from ~/.valni/agent or <cwd>/.valni.
 	appendSystemPromptOverride: () => [],
 });
 await loader1.reload();

package/runtime/examples/sdk/04-skills.ts

@@ -37,7 +37,7 @@ const loader = new DefaultResourceLoader({
 });
 await loader.reload();
 
-// Discover all skills from cwd/.pi/skills, ~/.pi/agent/skills, etc.
+// Discover all skills from cwd/.valni/skills, ~/.valni/agent/skills, etc.
 const { skills: allSkills, diagnostics } = loader.getSkills();
 console.log(
 	"Discovered skills:",

package/runtime/examples/sdk/05-tools.ts

@@ -7,7 +7,7 @@
  * createAgentSession() applies that cwd when it builds the actual built-in tools.
  *
  * For custom tools, see 06-extensions.ts - custom tools are registered via the
- * extensions system using pi.registerTool().
+ * extensions system using valni.registerTool().
  */
 
 import { createAgentSession, SessionManager } from "@valni/cli";

package/runtime/examples/sdk/06-extensions.ts

@@ -5,12 +5,12 @@
  * They provide a unified system for extensions, custom tools, commands, and more.
  *
  * By default, extension files are discovered from:
- * - ~/.pi/agent/extensions/
- * - <cwd>/.pi/extensions/
+ * - ~/.valni/agent/extensions/
+ * - <cwd>/.valni/extensions/
  * - Paths specified in settings.json "extensions" array
  *
  * An extension is a TypeScript file that exports a default function:
- *   export default function (pi: ExtensionAPI) { ... }
+ *   export default function (valni: ExtensionAPI) { ... }
  */
 
 import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } from "@valni/cli";
@@ -23,8 +23,8 @@ const resourceLoader = new DefaultResourceLoader({
 	agentDir: getAgentDir(),
 	additionalExtensionPaths: ["./my-logging-extension.ts", "./my-safety-extension.ts"],
 	extensionFactories: [
-		(pi) => {
-			pi.on("agent_start", () => {
+		(valni) => {
+			valni.on("agent_start", () => {
 				console.log("[Inline Extension] Agent starting");
 			});
 		},
@@ -54,23 +54,23 @@ try {
 /*
 import type { ExtensionAPI } from "@valni/cli";
 
-export default function (pi: ExtensionAPI) {
-	pi.on("agent_start", async () => {
+export default function (valni: ExtensionAPI) {
+	valni.on("agent_start", async () => {
 		console.log("[Extension] Agent starting");
 	});
 
-	pi.on("tool_call", async (event) => {
+	valni.on("tool_call", async (event) => {
 		console.log(\`[Extension] Tool: \${event.toolName}\`);
 		// Return { block: true, reason: "..." } to block execution
 		return undefined;
 	});
 
-	pi.on("agent_end", async (event) => {
+	valni.on("agent_end", async (event) => {
 		console.log(\`[Extension] Done, \${event.messages.length} messages\`);
 	});
 
 	// Register a custom tool
-	pi.registerTool({
+	valni.registerTool({
 		name: "my_tool",
 		label: "My Tool",
 		description: "Does something useful",
@@ -84,7 +84,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Register a command
-	pi.registerCommand("mycommand", {
+	valni.registerCommand("mycommand", {
 		description: "Do something",
 		handler: async (args, ctx) => {
 			ctx.ui.notify(\`Command executed with: \${args}\`);

package/runtime/examples/sdk/08-prompt-templates.ts

@@ -36,7 +36,7 @@ const loader = new DefaultResourceLoader({
 });
 await loader.reload();
 
-// Discover templates from cwd/.pi/prompts/ and ~/.pi/agent/prompts/
+// Discover templates from cwd/.valni/prompts/ and ~/.valni/agent/prompts/
 const discovered = loader.getPrompts().prompts;
 console.log("Discovered prompt templates:");
 for (const template of discovered) {