lsd-pi 1.1.2 → 1.1.3

package/src/resources/extensions/subagent/model-resolution.ts

@@ -8,18 +8,55 @@ export interface ResolveSubagentModelOptions {
 	parentModel?: { provider: string; id: string };
 }
 
+const BARE_MODEL_PROVIDER_RULES: Array<{ provider: string; matches: (modelId: string) => boolean }> = [
+	{ provider: "anthropic", matches: (modelId) => modelId.startsWith("claude-") },
+	{ provider: "google", matches: (modelId) => modelId.startsWith("gemini-") },
+	{
+		provider: "openai",
+		matches: (modelId) => /^(gpt-|o[134]-|omni-|text-embedding-)/.test(modelId),
+	},
+	{ provider: "xai", matches: (modelId) => modelId.startsWith("grok-") },
+	{
+		provider: "mistral",
+		matches: (modelId) => /^(mistral-|ministral-|codestral-)/.test(modelId),
+	},
+	{ provider: "groq", matches: (modelId) => modelId.startsWith("llama-") || modelId.startsWith("mixtral-") },
+];
+
+export function inferProviderForBareModel(modelId: string): string | undefined {
+	const normalizedModelId = modelId.trim().toLowerCase();
+	if (!normalizedModelId) return undefined;
+	return BARE_MODEL_PROVIDER_RULES.find((rule) => rule.matches(normalizedModelId))?.provider;
+}
+
+export function isQualifiedSubagentModel(model: string): boolean {
+	const trimmed = model.trim();
+	if (!trimmed || trimmed.includes(" ")) return false;
+	const parts = trimmed.split("/");
+	return parts.length === 2 && parts.every(Boolean);
+}
+
+export function normalizeSubagentModel(model: string | undefined | null): string | undefined {
+	const trimmed = model?.trim();
+	if (!trimmed || trimmed.startsWith("$")) return undefined;
+	if (isQualifiedSubagentModel(trimmed)) return trimmed;
+	if (trimmed.includes("/")) return undefined;
+	const inferredProvider = inferProviderForBareModel(trimmed);
+	return inferredProvider ? `${inferredProvider}/${trimmed}` : undefined;
+}
+
 export function resolveSubagentModel(
 	agent: ResolvedSubagentAgent,
 	options: ResolveSubagentModelOptions = {},
 ): string | undefined {
-	const overrideModel = options.overrideModel?.trim();
+	const overrideModel = normalizeSubagentModel(options.overrideModel);
 	if (overrideModel) return overrideModel;
 
-	const agentModel = agent.model?.trim();
+	const agentModel = normalizeSubagentModel(agent.model);
 	if (agentModel) return agentModel;
 
 	if (options.parentModel?.provider && options.parentModel?.id) {
-		return `${options.parentModel.provider}/${options.parentModel.id}`;
+		return normalizeSubagentModel(`${options.parentModel.provider}/${options.parentModel.id}`);
 	}
 
 	return undefined;

package/src/resources/extensions/usage/extension-manifest.json

@@ -0,0 +1,11 @@
+{
+  "id": "usage",
+  "name": "Usage",
+  "version": "1.0.0",
+  "description": "Show built-in LSD token and cost usage reports aggregated from session history",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "commands": ["usage"]
+  }
+}

package/src/resources/extensions/usage/index.ts

@@ -0,0 +1,441 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { homedir } from "node:os";
+
+type GroupBy = "model" | "project" | "project-model";
+type Scope = "all-projects" | "current-project";
+
+function getSessionsRoot(): string {
+	const appRoot = process.env.LSD_HOME || join(homedir(), ".lsd");
+	return join(appRoot, "sessions");
+}
+
+function getCurrentProjectSessionsDir(cwd: string): string {
+	const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+	return join(getSessionsRoot(), safePath);
+}
+
+type UsageRow = {
+	key: string;
+	project: string;
+	model: string;
+	messages: number;
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	total: number;
+	cost: number;
+};
+
+type UsageReport = {
+	label: string;
+	scope: Scope;
+	groupBy: GroupBy;
+	sessionsRoot: string;
+	filesScanned: number;
+	matchedMessages: number;
+	rows: UsageRow[];
+	totals: Omit<UsageRow, "key" | "project" | "model">;
+};
+
+type ParsedArgs = {
+	label: string;
+	startMs: number;
+	endMs: number;
+	scope: Scope;
+	groupBy: GroupBy;
+	json: boolean;
+};
+
+type SessionHeaderLike = {
+	type?: string;
+	cwd?: string;
+};
+
+type AssistantMessageLike = {
+	role?: string;
+	provider?: string;
+	model?: string;
+	timestamp?: number;
+	usage?: {
+		input?: number;
+		output?: number;
+		cacheRead?: number;
+		cacheWrite?: number;
+		cost?: { total?: number };
+	};
+};
+
+function startOfLocalDay(date: Date): number {
+	return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+
+function endOfLocalDay(date: Date): number {
+	return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1).getTime();
+}
+
+function formatInt(value: number): string {
+	return Math.round(value).toLocaleString();
+}
+
+function formatCost(value: number): string {
+	return `$${value.toFixed(4)}`;
+}
+
+function parseRangeToken(token: string | undefined): { label: string; startMs: number; endMs: number } {
+	const trimmed = token?.trim();
+	if (!trimmed || trimmed === "today") {
+		const now = new Date();
+		return {
+			label: "today",
+			startMs: startOfLocalDay(now),
+			endMs: endOfLocalDay(now),
+		};
+	}
+
+	const rollingMatch = trimmed.match(/^(\d+)d$/i);
+	if (rollingMatch) {
+		const days = Math.max(1, Number.parseInt(rollingMatch[1] ?? "1", 10));
+		const now = new Date();
+		return {
+			label: `${days}d`,
+			startMs: startOfLocalDay(new Date(now.getFullYear(), now.getMonth(), now.getDate() - (days - 1))),
+			endMs: endOfLocalDay(now),
+		};
+	}
+
+	const dateMatch = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+	if (dateMatch) {
+		const year = Number.parseInt(dateMatch[1] ?? "0", 10);
+		const month = Number.parseInt(dateMatch[2] ?? "1", 10) - 1;
+		const day = Number.parseInt(dateMatch[3] ?? "1", 10);
+		const date = new Date(year, month, day);
+		if (!Number.isNaN(date.getTime())) {
+			return {
+				label: trimmed,
+				startMs: startOfLocalDay(date),
+				endMs: endOfLocalDay(date),
+			};
+		}
+	}
+
+	throw new Error(`Invalid usage range "${trimmed}". Use: today, 7d, or YYYY-MM-DD.`);
+}
+
+function parseArgs(rawArgs: string): ParsedArgs {
+	const tokens = rawArgs.trim().split(/\s+/).filter(Boolean);
+	let rangeToken: string | undefined;
+	let scope: Scope = "all-projects";
+	let groupBy: GroupBy = "model";
+	let json = false;
+
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "--project-current") {
+			scope = "current-project";
+			continue;
+		}
+		if (token === "--all-projects") {
+			scope = "all-projects";
+			continue;
+		}
+		if (token === "--json") {
+			json = true;
+			continue;
+		}
+		if (token === "--by") {
+			const next = tokens[i + 1];
+			if (next !== "model" && next !== "project" && next !== "project-model") {
+				throw new Error('Invalid --by value. Use: model, project, or project-model.');
+			}
+			groupBy = next;
+			i++;
+			continue;
+		}
+		if (token.startsWith("--")) {
+			throw new Error(`Unknown flag: ${token}`);
+		}
+		if (!rangeToken) {
+			rangeToken = token;
+			continue;
+		}
+		throw new Error(`Unexpected argument: ${token}`);
+	}
+
+	const range = parseRangeToken(rangeToken);
+	return {
+		...range,
+		scope,
+		groupBy,
+		json,
+	};
+}
+
+function walkJsonlFiles(dir: string): string[] {
+	if (!existsSync(dir)) return [];
+	const out: string[] = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			out.push(...walkJsonlFiles(fullPath));
+			continue;
+		}
+		if (entry.isFile() && fullPath.endsWith(".jsonl")) {
+			out.push(fullPath);
+		}
+	}
+	return out;
+}
+
+function normalizeProjectLabel(cwd: string | undefined, fallbackPath: string): string {
+	if (cwd && cwd.trim()) return cwd;
+	return basename(fallbackPath);
+}
+
+function makeModelLabel(message: AssistantMessageLike): string {
+	if (message.provider && message.model) return `${message.provider}/${message.model}`;
+	if (message.model) return message.model;
+	return "unknown";
+}
+
+function makeGroupKey(groupBy: GroupBy, project: string, model: string): string {
+	switch (groupBy) {
+		case "project":
+			return project;
+		case "project-model":
+			return `${project} :: ${model}`;
+		case "model":
+		default:
+			return model;
+	}
+}
+
+function collectUsage(sessionFiles: string[], startMs: number, endMs: number, scope: Scope, groupBy: GroupBy): UsageReport {
+	const rows = new Map<string, UsageRow>();
+	let filesScanned = 0;
+	let matchedMessages = 0;
+
+	for (const file of sessionFiles) {
+		filesScanned++;
+		let projectLabel = basename(file);
+		let headerResolved = false;
+
+		const raw = readFileSync(file, "utf-8");
+		for (const line of raw.split("\n")) {
+			if (!line.trim()) continue;
+			let parsed: any;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				continue;
+			}
+
+			if (!headerResolved) {
+				const header = parsed as SessionHeaderLike;
+				if (header.type === "session") {
+					projectLabel = normalizeProjectLabel(header.cwd, file);
+					headerResolved = true;
+				}
+			}
+
+			const message = parsed?.type === "message" ? (parsed.message as AssistantMessageLike | undefined) : undefined;
+			if (!message || message.role !== "assistant") continue;
+
+			const timestamp = Number(message.timestamp ?? 0);
+			if (!timestamp || timestamp < startMs || timestamp >= endMs) continue;
+
+			matchedMessages++;
+			const model = makeModelLabel(message);
+			const key = makeGroupKey(groupBy, projectLabel, model);
+			const usage = message.usage ?? {};
+			const input = Number(usage.input ?? 0);
+			const output = Number(usage.output ?? 0);
+			const cacheRead = Number(usage.cacheRead ?? 0);
+			const cacheWrite = Number(usage.cacheWrite ?? 0);
+			const cost = Number(usage.cost?.total ?? 0);
+			const total = input + output + cacheRead + cacheWrite;
+
+			const existing = rows.get(key) ?? {
+				key,
+				project: groupBy === "model" ? "—" : projectLabel,
+				model: groupBy === "project" ? "—" : model,
+				messages: 0,
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0,
+				cost: 0,
+			};
+
+			existing.messages += 1;
+			existing.input += input;
+			existing.output += output;
+			existing.cacheRead += cacheRead;
+			existing.cacheWrite += cacheWrite;
+			existing.total += total;
+			existing.cost += cost;
+			rows.set(key, existing);
+		}
+	}
+
+	const orderedRows = [...rows.values()].sort((left, right) => {
+		if (right.total !== left.total) return right.total - left.total;
+		return left.key.localeCompare(right.key);
+	});
+
+	const totals = orderedRows.reduce(
+		(acc, row) => {
+			acc.messages += row.messages;
+			acc.input += row.input;
+			acc.output += row.output;
+			acc.cacheRead += row.cacheRead;
+			acc.cacheWrite += row.cacheWrite;
+			acc.total += row.total;
+			acc.cost += row.cost;
+			return acc;
+		},
+		{ messages: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, cost: 0 },
+	);
+
+	return {
+		label: "",
+		scope,
+		groupBy,
+		sessionsRoot: getSessionsRoot(),
+		filesScanned,
+		matchedMessages,
+		rows: orderedRows,
+		totals,
+	};
+}
+
+function renderTable(report: UsageReport): string {
+	const firstColumnHeader = report.groupBy === "project"
+		? "project"
+		: report.groupBy === "project-model"
+			? "project :: model"
+			: "model";
+
+	const displayRows = report.rows.map((row) => ({
+		label: row.key,
+		msgs: String(row.messages),
+		input: formatInt(row.input),
+		output: formatInt(row.output),
+		read: formatInt(row.cacheRead),
+		write: formatInt(row.cacheWrite),
+		total: formatInt(row.total),
+		cost: formatCost(row.cost),
+	}));
+
+	const widths = {
+		label: Math.max(firstColumnHeader.length, ...displayRows.map((row) => row.label.length), 5),
+		msgs: Math.max(4, ...displayRows.map((row) => row.msgs.length), String(report.totals.messages).length),
+		input: Math.max(5, ...displayRows.map((row) => row.input.length), formatInt(report.totals.input).length),
+		output: Math.max(6, ...displayRows.map((row) => row.output.length), formatInt(report.totals.output).length),
+		read: Math.max(4, ...displayRows.map((row) => row.read.length), formatInt(report.totals.cacheRead).length),
+		write: Math.max(5, ...displayRows.map((row) => row.write.length), formatInt(report.totals.cacheWrite).length),
+		total: Math.max(5, ...displayRows.map((row) => row.total.length), formatInt(report.totals.total).length),
+		cost: Math.max(7, ...displayRows.map((row) => row.cost.length), formatCost(report.totals.cost).length),
+	};
+
+	const header = [
+		firstColumnHeader.padEnd(widths.label),
+		"msgs".padStart(widths.msgs),
+		"input".padStart(widths.input),
+		"output".padStart(widths.output),
+		"read".padStart(widths.read),
+		"write".padStart(widths.write),
+		"total".padStart(widths.total),
+		"cost".padStart(widths.cost),
+	].join("  ");
+
+	const divider = "-".repeat(header.length);
+	const body = displayRows.map((row) => [
+		row.label.padEnd(widths.label),
+		row.msgs.padStart(widths.msgs),
+		row.input.padStart(widths.input),
+		row.output.padStart(widths.output),
+		row.read.padStart(widths.read),
+		row.write.padStart(widths.write),
+		row.total.padStart(widths.total),
+		row.cost.padStart(widths.cost),
+	].join("  "));
+
+	const totalsLine = [
+		"TOTAL".padEnd(widths.label),
+		String(report.totals.messages).padStart(widths.msgs),
+		formatInt(report.totals.input).padStart(widths.input),
+		formatInt(report.totals.output).padStart(widths.output),
+		formatInt(report.totals.cacheRead).padStart(widths.read),
+		formatInt(report.totals.cacheWrite).padStart(widths.write),
+		formatInt(report.totals.total).padStart(widths.total),
+		formatCost(report.totals.cost).padStart(widths.cost),
+	].join("  ");
+
+	return [header, divider, ...body, divider, totalsLine].join("\n");
+}
+
+function renderReport(report: UsageReport): string {
+	const scopeLabel = report.scope === "all-projects" ? "all projects" : "current project";
+	const summary = [
+		`Usage report: ${report.label}`,
+		`Scope: ${scopeLabel}`,
+		`Grouped by: ${report.groupBy}`,
+		`Sessions root: ${report.sessionsRoot}`,
+		`Session files scanned: ${report.filesScanned}`,
+		`Assistant messages matched: ${report.matchedMessages}`,
+	].join("\n");
+
+	if (report.rows.length === 0) {
+		return `${summary}\n\nNo assistant usage found for that range.`;
+	}
+
+	return `${summary}\n\n\
+\`\`\`text\n${renderTable(report)}\n\`\`\``;
+}
+
+function buildUsageReport(ctx: ExtensionCommandContext, args: ParsedArgs): UsageReport {
+	const sessionFiles = args.scope === "current-project"
+		? walkJsonlFiles(getCurrentProjectSessionsDir(ctx.cwd))
+		: walkJsonlFiles(getSessionsRoot());
+	const report = collectUsage(sessionFiles, args.startMs, args.endMs, args.scope, args.groupBy);
+	report.label = args.label;
+	return report;
+}
+
+export default function usageExtension(pi: ExtensionAPI) {
+	pi.registerCommand("usage", {
+		description: "Show token and cost usage from LSD sessions (today by model by default)",
+		async handler(rawArgs: string, ctx: ExtensionCommandContext) {
+			try {
+				const parsed = parseArgs(rawArgs);
+				const report = buildUsageReport(ctx, parsed);
+				const content = parsed.json
+					? `\`\`\`json\n${JSON.stringify(report, null, 2)}\n\`\`\``
+					: renderReport(report);
+
+				pi.sendMessage({
+					customType: "usage-report",
+					content,
+					display: true,
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : "Unknown error";
+				ctx.ui.notify(
+					`${message}\nUsage: /usage [today|7d|YYYY-MM-DD] [--project-current|--all-projects] [--by model|project|project-model] [--json]`,
+					"error",
+				);
+			}
+		},
+	});
+}
+
+export const __testing = {
+	parseArgs,
+	parseRangeToken,
+	renderTable,
+	collectUsage,
+};

package/{dist/resources/skills/create-gsd-extension → src/resources/skills/create-lsd-extension}/SKILL.md

@@ -1,17 +1,17 @@
 ---
-name: create-gsd-extension
-description: Create, debug, and iterate on GSD extensions (TypeScript modules that add tools, commands, event hooks, custom UI, and providers to GSD). Use when asked to build an extension, add a tool the LLM can call, register a slash command, hook into GSD events, create custom TUI components, or modify GSD behavior. Triggers on "create extension", "build extension", "add a tool", "register command", "hook into gsd", "custom tool", "gsd plugin", "gsd extension".
+name: create-lsd-extension
+description: Create, debug, and iterate on LSD extensions (TypeScript modules that add tools, commands, event hooks, custom UI, and providers to LSD). Use when asked to build an extension, add a tool the LLM can call, register a slash command, hook into LSD events, create custom TUI components, or modify LSD behavior. Triggers on "create extension", "build extension", "add a tool", "register command", "hook into lsd", "custom tool", "lsd plugin", "lsd extension".
 ---
 
 <essential_principles>
 
-**Extensions are TypeScript modules** that hook into GSD's runtime (built on pi). They export a default function receiving `ExtensionAPI` and use it to subscribe to events, register tools/commands/shortcuts, and interact with the session.
+**Extensions are TypeScript modules** that hook into LSD's runtime (built on pi). They export a default function receiving `ExtensionAPI` and use it to subscribe to events, register tools/commands/shortcuts, and interact with the session.
 
-**GSD extension paths (community/user-installed extensions):**
+**LSD extension paths (community/user-installed extensions):**
 - Global: `~/.pi/agent/extensions/*.ts` or `~/.pi/agent/extensions/*/index.ts`
 - Project-local: `.gsd/extensions/*.ts` or `.gsd/extensions/*/index.ts`
 
-Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the gsd-pi package. Community extensions placed there are silently ignored by the loader.
+Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the lsd-pi package. Community extensions placed there are silently ignored by the loader.
 
 **The three primitives:**
 1. **Events** — Listen and react (`pi.on("event", handler)`). Can block tool calls, modify messages, inject context.
@@ -79,7 +79,7 @@ All domain knowledge in `references/`:
 <success_criteria>
 Extension is complete when:
 - TypeScript compiles without errors (jiti handles this at runtime)
-- Extension loads on GSD startup or `/reload` without errors
+- Extension loads on LSD startup or `/reload` without errors
 - Tools appear in the LLM's system prompt and are callable
 - Commands respond to `/command` input
 - Event hooks fire at the expected lifecycle points

package/{dist/resources/skills/create-gsd-extension → src/resources/skills/create-lsd-extension}/references/custom-tools.md

@@ -149,7 +149,7 @@ pi.registerTool({
 });
 ```
 
-Start with no built-in tools: `gsd --no-tools -e ./my-extension.ts`
+Start with no built-in tools: `lsd --no-tools -e ./my-extension.ts`
 </overriding_builtins>
 
 <multiple_tools>

package/src/resources/skills/{create-gsd-extension → create-lsd-extension}/references/extension-lifecycle.md

@@ -3,10 +3,10 @@ The extension lifecycle from load to shutdown, including the full event flow.
 </overview>
 
 <loading>
-Extensions load when GSD starts (or on `/reload`). The default export function runs synchronously — subscribe to events and register tools/commands during this call.
+Extensions load when LSD starts (or on `/reload`). The default export function runs synchronously — subscribe to events and register tools/commands during this call.
 
 ```
-GSD starts
+LSD starts
   └─► Extension default function runs
       ├── pi.on("event", handler)      ← Subscribe
       ├── pi.registerTool({...})       ← Register tools

package/src/resources/skills/{create-gsd-extension → create-lsd-extension}/references/extensioncontext-reference.md

@@ -21,7 +21,7 @@ ctx.ui.setStatus("my-ext", "● Active");             // Footer status
 ctx.ui.setStatus("my-ext", undefined);              // Clear
 ctx.ui.setWidget("my-id", ["Line 1", "Line 2"]);   // Widget above editor
 ctx.ui.setWidget("my-id", ["Below!"], { placement: "belowEditor" });
-ctx.ui.setTitle("gsd - my project");                 // Terminal title
+ctx.ui.setTitle("lsd - my project");                 // Terminal title
 ctx.ui.setEditorText("Prefill");                    // Set editor content
 ctx.ui.setWorkingMessage("Analyzing...");           // Working message during streaming
 ctx.ui.setToolsExpanded(true);                      // Expand tool output

package/{dist/resources/skills/create-gsd-extension → src/resources/skills/create-lsd-extension}/references/key-rules-gotchas.md

@@ -1,5 +1,5 @@
 <overview>
-Non-negotiable rules and common gotchas when building GSD extensions.
+Non-negotiable rules and common gotchas when building LSD extensions.
 </overview>
 
 <must_follow>
@@ -22,16 +22,16 @@ Non-negotiable rules and common gotchas when building GSD extensions.
 - Overlay components are **disposed when closed** — create fresh instances each time
 - Treat `ctx.reload()` as terminal — code after runs from pre-reload version
 - Check `ctx.hasUI` before dialog methods (false in print/JSON mode)
-- Extension errors are logged but don't crash GSD — tool_call handler errors fail-safe (block the tool)
+- Extension errors are logged but don't crash LSD — tool_call handler errors fail-safe (block the tool)
 </common_patterns>
 
 <gsd_paths>
-**GSD extension paths (community/user-installed extensions):**
+**LSD extension paths (community/user-installed extensions):**
 - Global: `~/.pi/agent/extensions/*.ts`
 - Global (subdir): `~/.pi/agent/extensions/*/index.ts`
 - Project-local: `.gsd/extensions/*.ts`
 - Project-local (subdir): `.gsd/extensions/*/index.ts`
 
-Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the gsd-pi package.
+Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the lsd-pi package.
 Community extensions placed there are silently ignored by the loader.
 </gsd_paths>

package/src/resources/skills/{create-gsd-extension → create-lsd-extension}/references/packaging-distribution.md

@@ -1,5 +1,5 @@
 <overview>
-Packaging extensions for distribution via npm, git, or local paths. Creating GSD/pi packages.
+Packaging extensions for distribution via npm, git, or local paths. Creating LSD/pi packages.
 </overview>
 
 <package_manifest>
@@ -7,7 +7,7 @@ Add a `pi` manifest to `package.json`:
 
 ```json
 {
-  "name": "my-gsd-package",
+  "name": "my-lsd-package",
   "keywords": ["pi-package"],
   "pi": {
     "extensions": ["./extensions"],
@@ -21,12 +21,12 @@ Add a `pi` manifest to `package.json`:
 
 <installing>
 ```bash
-gsd install npm:@foo/bar@1.0.0
-gsd install git:github.com/user/repo@v1
-gsd install ./local/path
+lsd install npm:@foo/bar@1.0.0
+lsd install git:github.com/user/repo@v1
+lsd install ./local/path
 
 # Try without installing:
-gsd -e npm:@foo/bar
+lsd -e npm:@foo/bar
 ```
 </installing>
 

package/src/resources/skills/{create-gsd-extension → create-lsd-extension}/workflows/create-extension.md

@@ -12,7 +12,7 @@
 ## Step 1: Determine Scope and Placement
 
 Ask the user:
-- **Global** (`~/.pi/agent/extensions/`) — Available in all GSD sessions
+- **Global** (`~/.pi/agent/extensions/`) — Available in all LSD sessions
 - **Project-local** (`.gsd/extensions/`) — Available only in this project
 
 ## Step 2: Determine Extension Capabilities
@@ -124,14 +124,14 @@ pi.on("tool_call", async (event, ctx) => {
 
 ```bash
 # Quick test without installing
-gsd -e ./path/to/my-extension.ts
+lsd -e ./path/to/my-extension.ts
 
 # Or place in extensions dir and reload
 /reload
 ```
 
 Verify:
-- Extension loads without errors (check GSD startup output)
+- Extension loads without errors (check LSD startup output)
 - Tools appear when LLM is asked to use them
 - Commands respond to `/mycommand`
 - Event hooks trigger at expected points