lsd-pi 1.1.10 → 1.2.1

package/dist/resources/extensions/slash-commands/tools.js

@@ -6,11 +6,6 @@ function getSettingsManager() {
 function isHashlineMode(activeToolNames) {
     return activeToolNames.includes("hashline_read") || activeToolNames.includes("hashline_edit");
 }
-function getCoreToolNames(activeToolNames) {
-    return isHashlineMode(activeToolNames)
-        ? ["hashline_read", "bash", "lsp", "tool_search", "tool_enable"]
-        : ["read", "bash", "lsp", "tool_search", "tool_enable"];
-}
 function getBalancedToolNames(activeToolNames) {
     return isHashlineMode(activeToolNames)
         ? [
@@ -25,6 +20,7 @@ function getBalancedToolNames(activeToolNames) {
             "Skill",
             "subagent",
             "await_subagent",
+            "ask_user_questions",
         ]
         : [
             "read",
@@ -38,8 +34,12 @@ function getBalancedToolNames(activeToolNames) {
             "Skill",
             "subagent",
             "await_subagent",
+            "ask_user_questions",
         ];
 }
+function getFullToolNames(pi) {
+    return pi.getAllTools().map((tool) => tool.name).filter((name) => Boolean(name));
+}
 function scoreTool(query, tool) {
     const name = (tool.name ?? "").toLowerCase();
     const description = (tool.description ?? "").toLowerCase();
@@ -153,43 +153,30 @@ export default function toolSearchExtension(pi) {
         },
     });
     pi.registerCommand("tools", {
-        description: "Toggle lazy tool-search mode",
+        description: "Manage default tool profiles",
         handler: async (args, _ctx) => {
             const input = args.trim();
             const settings = getSettingsManager();
             const currentActive = pi.getActiveTools();
             const toolProfile = settings.getToolProfile();
-            const toolSearchEnabled = toolProfile === "minimal";
             if (!input) {
                 pi.sendMessage({
                     customType: "tools:status",
                     content: [
                         `Tool profile: ${toolProfile}`,
-                        `Tool search mode: ${toolSearchEnabled ? "on" : "off"}`,
                         `Active tools: ${currentActive.length}`,
                         currentActive.length > 0 ? currentActive.join(", ") : "(none)",
                         "",
                         "Usage:",
-                        "  /tools on         Enable lazy tool-search mode and switch to a small core tool set",
-                        "  /tools off        Disable lazy tool-search mode and restore the balanced tool profile",
                         "  /tools balanced   Switch to the balanced tool profile",
-                        "  /tools minimal    Switch to the minimal core tool profile",
+                        "  /tools full       Switch to the full tool profile (all available tools)",
+                        "  /tools on         Alias for /tools full",
+                        "  /tools off        Alias for /tools balanced",
                     ].join("\n"),
                     display: true,
                 });
                 return;
             }
-            if (["on", "enable", "mode on"].includes(input)) {
-                settings.setToolProfile("minimal");
-                const nextActive = getCoreToolNames(currentActive);
-                pi.setActiveTools(nextActive);
-                pi.sendMessage({
-                    customType: "tools:mode",
-                    content: `Tool search mode enabled. Active tools reduced to: ${pi.getActiveTools().join(", ")}`,
-                    display: true,
-                });
-                return;
-            }
             if (["off", "disable", "mode off", "balanced", "default"].includes(input)) {
                 settings.setToolProfile("balanced");
                 const nextActive = getBalancedToolNames(currentActive);
@@ -201,20 +188,20 @@ export default function toolSearchExtension(pi) {
                 });
                 return;
             }
-            if (["minimal", "core"].includes(input)) {
-                settings.setToolProfile("minimal");
-                const nextActive = getCoreToolNames(currentActive);
+            if (["on", "enable", "mode on", "full", "all"].includes(input)) {
+                settings.setToolProfile("full");
+                const nextActive = getFullToolNames(pi);
                 pi.setActiveTools(nextActive);
                 pi.sendMessage({
                     customType: "tools:mode",
-                    content: `Minimal tool profile active: ${pi.getActiveTools().join(", ")}`,
+                    content: `Full tool profile active: ${pi.getActiveTools().join(", ")}`,
                     display: true,
                 });
                 return;
             }
             pi.sendMessage({
                 customType: "tools:help",
-                content: `Unknown /tools subcommand: ${input}\n\nTry /tools, /tools on, /tools off, /tools balanced, or /tools minimal.`,
+                content: `Unknown /tools subcommand: ${input}\n\nTry /tools, /tools balanced, /tools full, /tools on, or /tools off.`,
                 display: true,
             });
         },

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

@@ -579,7 +579,7 @@ const ChainItem = Type.Object({
     })),
 });
 const AgentScopeSchema = StringEnum(["user", "project", "both"], {
-    description: 'Which agent directories to use. Default: "both" (user + project-local).',
+    description: 'Which agent directories to use. Default: "both".',
     default: "both",
 });
 const SubagentParams = Type.Object({
@@ -786,15 +786,21 @@ export default function (pi) {
             "Modes: single ({ agent, task }), parallel ({ tasks: [{agent, task},...] }), chain ({ chain: [{agent, task},...] } with {previous} placeholder).",
             "Agents are defined as .md files in the configured user agent directory (for LSD this is typically ~/.lsd/agent/agents/) or project-local .lsd/agents/, with legacy support for .gsd/agents/ and .pi/agents/.",
             "Use the /subagent command to list available agents and their descriptions.",
-            "Use chain mode to pipeline: scout finds context, planner designs, worker implements.",
             "Set background: true (single mode only) to run detached — returns immediately with a sa_xxxx job ID. Completion is announced back into the session. Use await_subagent or /subagents to manage background jobs.",
         ].join(" "),
         promptGuidelines: [
             "Use subagent to delegate self-contained tasks that benefit from an isolated context window.",
-            "Use scout agent first when you need codebase context before implementing.",
-            "Use chain mode for scout→planner→worker or worker→reviewer→worker pipelines.",
+            "When scout is the right fit, call the subagent tool directly — do not type '/subagent' as a shell-like command.",
+            "Valid call shapes: single mode uses { agent, task }, parallel mode uses { tasks: [{ agent, task }, ...] }, and chain mode uses { chain: [{ agent, task }, ...] }.",
+            "Recon planning rule: use no scout for narrow known-file work, one scout for one broad unfamiliar subsystem, and parallel scouts only when the work spans multiple loosely-coupled subsystems.",
+            "Use scout only for broad or unfamiliar codebase reconnaissance before you read many files yourself; save direct reads for targeted lookups once the relevant files are known.",
+            "Do not use scout as the reviewer, auditor, or final judge. Scout should map architecture, files, ownership, and likely hotspots for another agent or the parent model to evaluate.",
+            "If understanding the task would require scanning multiple files or folders to figure out architecture, routes, data flow, or ownership, launch scout first with single mode: { agent: 'scout', task: '...' }.",
+            "If reconnaissance spans multiple loosely-coupled subsystems, prefer parallel scout subagents with { tasks: [{ agent: 'scout', task: 'map frontend...' }, { agent: 'scout', task: 'map backend...' }] }.",
+            "When using scout for a review-like request, phrase the task as mapping: ask for architecture, key files, hotspots, and likely risk areas to inspect next — not for a final ranked review.",
+            "For broad review or audit requests, use scout only as a prep step; the parent model or a reviewer should make the final judgments.",
+            "Skip scout when the user already named the exact file/function to inspect or the task is obviously narrow.",
             "Use parallel mode when tasks are independent and don't need each other's output.",
-            "Always check available agents with /subagent before choosing one.",
             "Use background: true when the user wants to keep chatting while a long-running agent works in parallel.",
             "If the user wants to wait for a background subagent result, use await_subagent.",
         ],
@@ -1081,8 +1087,7 @@ export default function (pi) {
             const scope = args.agentScope ?? "both";
             if (args.chain && args.chain.length > 0) {
                 let text = theme.fg("toolTitle", theme.bold("subagent ")) +
-                    theme.fg("accent", `chain (${args.chain.length} steps)`) +
-                    theme.fg("muted", ` [${scope}]`);
+                    theme.fg("accent", `chain (${args.chain.length} steps)`);
                 for (let i = 0; i < Math.min(args.chain.length, 3); i++) {
                     const step = args.chain[i];
                     // Clean up {previous} placeholder for display
@@ -1101,8 +1106,7 @@ export default function (pi) {
             }
             if (args.tasks && args.tasks.length > 0) {
                 let text = theme.fg("toolTitle", theme.bold("subagent ")) +
-                    theme.fg("accent", `parallel (${args.tasks.length} tasks)`) +
-                    theme.fg("muted", ` [${scope}]`);
+                    theme.fg("accent", `parallel (${args.tasks.length} tasks)`);
                 for (const t of args.tasks.slice(0, 3)) {
                     const preview = t.task.length > 40 ? `${t.task.slice(0, 40)}...` : t.task;
                     text += `\n  ${theme.fg("accent", t.agent)}${theme.fg("dim", ` ${preview}`)}`;
@@ -1114,8 +1118,7 @@ export default function (pi) {
             const agentName = args.agent || "...";
             const preview = args.task ? (args.task.length > 60 ? `${args.task.slice(0, 60)}...` : args.task) : "...";
             let text = theme.fg("toolTitle", theme.bold("subagent ")) +
-                theme.fg("accent", agentName) +
-                theme.fg("muted", ` [${scope}]`);
+                theme.fg("accent", agentName);
             text += `\n  ${theme.fg("dim", preview)}`;
             return new Text(text, 0, 0);
         },

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

@@ -222,12 +222,15 @@ function makeGroupKey(groupBy, project, model) {
 }
 function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
     const rows = new Map();
+    const userPromptRows = new Map();
     let filesScanned = 0;
     let matchedMessages = 0;
+    let matchedUserPrompts = 0;
     for (const file of sessionFiles) {
         filesScanned++;
         let projectLabel = basename(file);
         let headerResolved = false;
+        let currentModel = "";
         const raw = readFileSync(file, "utf-8");
         for (const line of raw.split("\n")) {
             if (!line.trim())
@@ -246,42 +249,83 @@ function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
                     headerResolved = true;
                 }
             }
+            // Track model changes
+            if (parsed?.type === "model_change" && parsed.provider && parsed.modelId) {
+                currentModel = `${parsed.provider}/${parsed.modelId}`;
+            }
             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)
+            if (!message)
                 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);
+            if (message.role === "assistant") {
+                const timestamp = Number(message.timestamp ?? 0);
+                if (!timestamp || timestamp < startMs || timestamp >= endMs)
+                    continue;
+                matchedMessages++;
+                const model = message.provider && message.model ? `${message.provider}/${message.model}` : currentModel;
+                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,
+                    userPrompts: 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);
+            }
+            else if (message.role === "user") {
+                const timestamp = Number(message.timestamp ?? 0);
+                if (!timestamp || timestamp < startMs || timestamp >= endMs)
+                    continue;
+                matchedUserPrompts++;
+                const model = currentModel;
+                const key = makeGroupKey(groupBy, projectLabel, model);
+                const existing = userPromptRows.get(key) ?? {
+                    key,
+                    project: groupBy === "model" ? "—" : projectLabel,
+                    model: groupBy === "project" ? "—" : model,
+                    messages: 0,
+                    userPrompts: 0,
+                    input: 0,
+                    output: 0,
+                    cacheRead: 0,
+                    cacheWrite: 0,
+                    total: 0,
+                    cost: 0,
+                };
+                existing.userPrompts += 1;
+                userPromptRows.set(key, existing);
+            }
+        }
+    }
+    // Merge user prompt counts into the main rows
+    for (const [key, userRow] of userPromptRows.entries()) {
+        const existing = rows.get(key);
+        if (existing) {
+            existing.userPrompts = userRow.userPrompts;
+        }
+        else {
+            // User prompts without assistant responses (edge case)
+            rows.set(key, userRow);
         }
     }
     const orderedRows = [...rows.values()].sort((left, right) => {
@@ -291,6 +335,7 @@ function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
     });
     const totals = orderedRows.reduce((acc, row) => {
         acc.messages += row.messages;
+        acc.userPrompts += row.userPrompts;
         acc.input += row.input;
         acc.output += row.output;
         acc.cacheRead += row.cacheRead;
@@ -298,7 +343,7 @@ function collectUsage(sessionFiles, startMs, endMs, scope, groupBy) {
         acc.total += row.total;
         acc.cost += row.cost;
         return acc;
-    }, { messages: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, cost: 0 });
+    }, { messages: 0, userPrompts: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, cost: 0 });
     return {
         label: "",
         scope,
@@ -318,6 +363,7 @@ function renderTable(report) {
             : "model";
     const displayRows = report.rows.map((row) => ({
         label: row.key,
+        userPrompts: String(row.userPrompts),
         msgs: String(row.messages),
         input: formatInt(row.input),
         output: formatInt(row.output),
@@ -328,6 +374,7 @@ function renderTable(report) {
     }));
     const widths = {
         label: Math.max(firstColumnHeader.length, ...displayRows.map((row) => row.label.length), 5),
+        userPrompts: Math.max(11, ...displayRows.map((row) => row.userPrompts.length), String(report.totals.userPrompts).length),
         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),
@@ -338,6 +385,7 @@ function renderTable(report) {
     };
     const header = [
         firstColumnHeader.padEnd(widths.label),
+        "user prompts".padStart(widths.userPrompts),
         "msgs".padStart(widths.msgs),
         "input".padStart(widths.input),
         "output".padStart(widths.output),
@@ -349,6 +397,7 @@ function renderTable(report) {
     const divider = "-".repeat(header.length);
     const body = displayRows.map((row) => [
         row.label.padEnd(widths.label),
+        row.userPrompts.padStart(widths.userPrompts),
         row.msgs.padStart(widths.msgs),
         row.input.padStart(widths.input),
         row.output.padStart(widths.output),
@@ -359,6 +408,7 @@ function renderTable(report) {
     ].join("  "));
     const totalsLine = [
         "TOTAL".padEnd(widths.label),
+        String(report.totals.userPrompts).padStart(widths.userPrompts),
         String(report.totals.messages).padStart(widths.msgs),
         formatInt(report.totals.input).padStart(widths.input),
         formatInt(report.totals.output).padStart(widths.output),
@@ -377,7 +427,8 @@ function renderReport(report) {
         `Grouped by: ${report.groupBy}`,
         `Sessions root: ${report.sessionsRoot}`,
         `Session files scanned: ${report.filesScanned}`,
-        `Assistant messages matched: ${report.matchedMessages}`,
+        `User prompts: ${report.totals.userPrompts}`,
+        `Assistant messages: ${report.matchedMessages}`,
     ].join("\n");
     if (report.rows.length === 0) {
         return `${summary}\n\nNo assistant usage found for that range.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lsd-pi",
-  "version": "1.1.10",
+  "version": "1.2.1",
   "description": "LSD — Looks Sort of Done coding agent",
   "license": "MIT",
   "repository": {

package/packages/pi-ai/dist/models.generated.d.ts

@@ -5994,6 +5994,108 @@ export declare const MODELS: {
         };
     };
     readonly "openai-codex": {
+        readonly "gpt-5": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
+        readonly "gpt-5-chat-latest": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: false;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
+        readonly "gpt-5-codex": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
+        readonly "gpt-5-mini": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
+        readonly "gpt-5-nano": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
+        readonly "gpt-5-pro": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
         readonly "gpt-5.1": {
             id: string;
             name: string;
@@ -6011,6 +6113,40 @@ export declare const MODELS: {
             contextWindow: number;
             maxTokens: number;
         };
+        readonly "gpt-5.1-chat-latest": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
+        readonly "gpt-5.1-codex": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
         readonly "gpt-5.1-codex-max": {
             id: string;
             name: string;
@@ -6062,6 +6198,23 @@ export declare const MODELS: {
             contextWindow: number;
             maxTokens: number;
         };
+        readonly "gpt-5.2-chat-latest": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
         readonly "gpt-5.2-codex": {
             id: string;
             name: string;
@@ -6079,6 +6232,23 @@ export declare const MODELS: {
             contextWindow: number;
             maxTokens: number;
         };
+        readonly "gpt-5.2-pro": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
         readonly "gpt-5.3-codex": {
             id: string;
             name: string;
@@ -6103,7 +6273,7 @@ export declare const MODELS: {
             provider: string;
             baseUrl: string;
             reasoning: true;
-            input: "text"[];
+            input: ("text" | "image")[];
             cost: {
                 input: number;
                 output: number;
@@ -6130,6 +6300,57 @@ export declare const MODELS: {
             contextWindow: number;
             maxTokens: number;
         };
+        readonly "gpt-5.4-mini": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
+        readonly "gpt-5.4-nano": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
+        readonly "gpt-5.4-pro": {
+            id: string;
+            name: string;
+            api: "openai-codex-responses";
+            provider: string;
+            baseUrl: string;
+            reasoning: true;
+            input: ("text" | "image")[];
+            cost: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+            };
+            contextWindow: number;
+            maxTokens: number;
+        };
     };
     readonly opencode: {
         readonly "big-pickle": {