lsd-pi 1.1.2 → 1.1.3

package/dist/resources/extensions/subagent/index.js

@@ -11,7 +11,7 @@
  *
  * Uses JSON mode to capture structured output from subagents.
  */
-import { spawn, execSync } from "node:child_process";
+import { spawn, execFileSync } from "node:child_process";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -22,18 +22,19 @@ import { Container, Markdown, Spacer, Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { formatTokenCount } from "../shared/mod.js";
 import { discoverAgents } from "./agents.js";
+import { buildSubagentProcessArgs, getBundledExtensionPathsFromEnv } from "./launch-helpers.js";
 import { createIsolation, mergeDeltaPatches, readIsolationMode, } from "./isolation.js";
 import { registerWorker, updateWorker } from "./worker-registry.js";
 import { handleSubagentPermissionRequest, isSubagentPermissionRequest } from "./approval-proxy.js";
 import { resolveConfiguredSubagentModel } from "./configured-model.js";
-import { resolveSubagentModel } from "./model-resolution.js";
+import { normalizeSubagentModel, resolveSubagentModel, } from "./model-resolution.js";
 import { loadEffectivePreferences } from "../shared/preferences.js";
 import { CmuxClient } from "../cmux/index.js";
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
 const COLLAPSED_ITEM_COUNT = 10;
 const liveSubagentProcesses = new Set();
-async function stopLiveSubagents() {
+export async function stopLiveSubagents() {
     const active = Array.from(liveSubagentProcesses);
     if (active.length === 0)
         return;
@@ -203,23 +204,14 @@ function readBudgetSubagentModelFromSettings() {
             return undefined;
         const raw = fs.readFileSync(settingsPath, "utf-8");
         const parsed = JSON.parse(raw);
-        return typeof parsed.budgetSubagentModel === "string" ? parsed.budgetSubagentModel.trim() || undefined : undefined;
+        return typeof parsed.budgetSubagentModel === "string"
+            ? normalizeSubagentModel(parsed.budgetSubagentModel)
+            : undefined;
     }
     catch {
         return undefined;
     }
 }
-function buildSubagentProcessArgs(agent, task, tmpPromptPath, model) {
-    const args = ["--mode", "json", "-p", "--no-session"];
-    if (model)
-        args.push("--model", model);
-    if (agent.tools && agent.tools.length > 0)
-        args.push("--tools", agent.tools.join(","));
-    if (tmpPromptPath)
-        args.push("--append-system-prompt", tmpPromptPath);
-    args.push(`Task: ${task}`);
-    return args;
-}
 function resolveSubagentCliPath(defaultCwd) {
     const candidates = [process.env.GSD_BIN_PATH, process.env.LSD_BIN_PATH, process.argv[1]]
         .map((value) => value?.trim())
@@ -235,7 +227,7 @@ function resolveSubagentCliPath(defaultCwd) {
     }
     for (const binName of ["lsd", "gsd"]) {
         try {
-            const resolved = execSync(`which ${binName}`, { encoding: "utf-8" }).trim();
+            const resolved = execFileSync("which", [binName], { encoding: "utf-8" }).trim();
             if (resolved)
                 return resolved;
         }
@@ -247,22 +239,22 @@ function resolveSubagentCliPath(defaultCwd) {
 }
 function processSubagentEventLine(line, currentResult, emitUpdate, proc) {
     if (!line.trim())
-        return;
+        return false;
     let event;
     try {
         event = JSON.parse(line);
     }
     catch {
-        return;
+        return false;
     }
     if (proc && isSubagentPermissionRequest(event)) {
         void handleSubagentPermissionRequest(event, proc, {
             requestFileChangeApproval,
             requestClassifierDecision,
         });
-        return;
+        return false;
     }
-    if (event.type === "message_end" && event.message) {
+    if ((event.type === "message_end" || event.type === "turn_end") && event.message) {
         const msg = event.message;
         currentResult.messages.push(msg);
         if (msg.role === "assistant") {
@@ -276,7 +268,7 @@ function processSubagentEventLine(line, currentResult, emitUpdate, proc) {
                 currentResult.usage.cost += usage.cost?.total || 0;
                 currentResult.usage.contextTokens = usage.totalTokens || 0;
             }
-            if (msg.model)
+            if (msg.model && (!currentResult.model || msg.model.includes("/")))
                 currentResult.model = msg.model;
             if (msg.stopReason)
                 currentResult.stopReason = msg.stopReason;
@@ -289,6 +281,7 @@ function processSubagentEventLine(line, currentResult, emitUpdate, proc) {
         currentResult.messages.push(event.message);
         emitUpdate();
     }
+    return event.type === "agent_end";
 }
 async function waitForFile(filePath, signal, timeoutMs = 30 * 60 * 1000) {
     const started = Date.now();
@@ -350,8 +343,8 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, mo
         const args = buildSubagentProcessArgs(agent, task, tmpPromptPath, inferredModel);
         let wasAborted = false;
         const exitCode = await new Promise((resolve) => {
-            const bundledPaths = (process.env.GSD_BUNDLED_EXTENSION_PATHS ?? "").split(path.delimiter).map(s => s.trim()).filter(Boolean);
-            const extensionArgs = bundledPaths.flatMap(p => ["--extension", p]);
+            const bundledPaths = getBundledExtensionPathsFromEnv();
+            const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
             const cliPath = resolveSubagentCliPath(cwd ?? defaultCwd);
             if (!cliPath) {
                 currentResult.stderr += "Unable to resolve LSD/GSD CLI path for subagent launch.";
@@ -359,23 +352,36 @@ async function runSingleAgent(defaultCwd, agents, agentName, task, cwd, step, mo
                 return;
             }
             const proc = spawn(process.execPath, [cliPath, ...extensionArgs, ...args], { cwd: cwd ?? defaultCwd, shell: false, stdio: ["pipe", "pipe", "pipe"] });
+            proc.stdin.end();
             liveSubagentProcesses.add(proc);
             let buffer = "";
+            let completionSeen = false;
             proc.stdout.on("data", (data) => {
                 buffer += data.toString();
                 const lines = buffer.split("\n");
                 buffer = lines.pop() || "";
-                for (const line of lines)
-                    processSubagentEventLine(line, currentResult, emitUpdate, proc);
+                for (const line of lines) {
+                    if (processSubagentEventLine(line, currentResult, emitUpdate, proc)) {
+                        completionSeen = true;
+                        try {
+                            proc.kill("SIGTERM");
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                }
             });
             proc.stderr.on("data", (data) => {
                 currentResult.stderr += data.toString();
             });
             proc.on("close", (code) => {
                 liveSubagentProcesses.delete(proc);
-                if (buffer.trim())
-                    processSubagentEventLine(buffer, currentResult, emitUpdate, proc);
-                resolve(code ?? 0);
+                if (buffer.trim()) {
+                    const completedOnFlush = processSubagentEventLine(buffer, currentResult, emitUpdate, proc);
+                    completionSeen = completionSeen || completedOnFlush;
+                }
+                resolve(completionSeen && (code === null || code === 143 || code === 15) ? 0 : (code ?? 0));
             });
             proc.on("error", () => {
                 liveSubagentProcesses.delete(proc);

package/dist/resources/extensions/subagent/launch-helpers.js

@@ -0,0 +1,24 @@
+import * as path from "node:path";
+export function getBundledExtensionPathsFromEnv(env = process.env) {
+    const rawPaths = [env.GSD_BUNDLED_EXTENSION_PATHS, env.LSD_BUNDLED_EXTENSION_PATHS]
+        .map((value) => value?.trim())
+        .filter((value) => Boolean(value));
+    const unique = new Set();
+    for (const raw of rawPaths) {
+        for (const entry of raw.split(path.delimiter).map((value) => value.trim()).filter(Boolean)) {
+            unique.add(entry);
+        }
+    }
+    return Array.from(unique);
+}
+export function buildSubagentProcessArgs(agent, task, tmpPromptPath, model) {
+    const args = ["--mode", "json", "-p", "--no-session"];
+    if (model)
+        args.push("--model", model);
+    if (agent.tools && agent.tools.length > 0)
+        args.push("--tools", agent.tools.join(","));
+    if (tmpPromptPath)
+        args.push("--append-system-prompt", tmpPromptPath);
+    args.push(`Task: ${task}`);
+    return args;
+}

package/dist/resources/extensions/subagent/model-resolution.js

@@ -1,12 +1,50 @@
+const BARE_MODEL_PROVIDER_RULES = [
+    { 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) {
+    const normalizedModelId = modelId.trim().toLowerCase();
+    if (!normalizedModelId)
+        return undefined;
+    return BARE_MODEL_PROVIDER_RULES.find((rule) => rule.matches(normalizedModelId))?.provider;
+}
+export function isQualifiedSubagentModel(model) {
+    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) {
+    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, options = {}) {
-    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/dist/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/dist/resources/extensions/usage/index.js

@@ -0,0 +1,346 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { homedir } from "node:os";
+function getSessionsRoot() {
+    const appRoot = process.env.LSD_HOME || join(homedir(), ".lsd");
+    return join(appRoot, "sessions");
+}
+function getCurrentProjectSessionsDir(cwd) {
+    const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+    return join(getSessionsRoot(), safePath);
+}
+function startOfLocalDay(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+function endOfLocalDay(date) {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1).getTime();
+}
+function formatInt(value) {
+    return Math.round(value).toLocaleString();
+}
+function formatCost(value) {
+    return `$${value.toFixed(4)}`;
+}
+function parseRangeToken(token) {
+    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) {
+    const tokens = rawArgs.trim().split(/\s+/).filter(Boolean);
+    let rangeToken;
+    let scope = "all-projects";
+    let 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) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    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, fallbackPath) {
+    if (cwd && cwd.trim())
+        return cwd;
+    return basename(fallbackPath);
+}
+function makeModelLabel(message) {
+    if (message.provider && message.model)
+        return `${message.provider}/${message.model}`;
+    if (message.model)
+        return message.model;
+    return "unknown";
+}
+function makeGroupKey(groupBy, project, model) {
+    switch (groupBy) {
+        case "project":
+            return project;
+        case "project-model":
+            return `${project} :: ${model}`;
+        case "model":
+        default:
+            return model;
+    }
+}
+function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
+    const rows = new Map();
+    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;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!headerResolved) {
+                const header = parsed;
+                if (header.type === "session") {
+                    projectLabel = normalizeProjectLabel(header.cwd, file);
+                    headerResolved = true;
+                }
+            }
+            const message = parsed?.type === "message" ? parsed.message : 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) {
+    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) {
+    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, args) {
+    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) {
+    pi.registerCommand("usage", {
+        description: "Show token and cost usage from LSD sessions (today by model by default)",
+        async handler(rawArgs, ctx) {
+            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/{src/resources/skills/create-gsd-extension → dist/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/{src/resources/skills/create-gsd-extension → dist/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/dist/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/dist/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