@pencil-agent/nano-pencil 1.14.2 → 1.14.4

package/dist/extensions/defaults/security-audit/index.js

@@ -16,6 +16,13 @@ import { DEFAULT_SECURITY_CONFIG } from "./interface.js";
 // Security Audit Extension
 // ============================================================
 const SECURITY_MESSAGE_TYPE = "security-audit";
+const SECURITY_ROOT_COMPLETIONS = [
+    { value: "dashboard", label: "dashboard", description: "Show recent warnings and blocked actions" },
+    { value: "logs", label: "logs", description: "Show detailed event history" },
+    { value: "stats", label: "stats", description: "Show event counts" },
+    { value: "clear", label: "clear", description: "Clear saved events" },
+];
+const SECURITY_LOG_LIMIT_COMPLETIONS = ["10", "20", "50", "100"];
 // Security mode: "audit" (warn only), "strict" (block dangerous)
 const SECURITY_MODE = process.env.SECURITY_MODE || "strict";
 const detector = new DangerDetector({
@@ -42,6 +49,26 @@ function sendSecurityNotice(api, content) {
         display: true,
     }, { triggerTurn: true });
 }
+function getSecurityArgumentCompletions(argumentPrefix, context) {
+    const prefix = argumentPrefix.trim().toLowerCase();
+    if (context?.previousTokens[0] === "logs" && context.tokenIndex === 1) {
+        const values = SECURITY_LOG_LIMIT_COMPLETIONS
+            .filter((value) => value.startsWith(prefix))
+            .map((value) => ({ value, label: value, description: `Show ${value} events` }));
+        return values.length > 0 ? values : null;
+    }
+    if (context && context.tokenIndex > 0)
+        return null;
+    const values = SECURITY_ROOT_COMPLETIONS.filter((item) => item.value.startsWith(prefix));
+    return values.length > 0 ? values.map((item) => ({ ...item })) : null;
+}
+function getSecurityLogLimitCompletions(argumentPrefix) {
+    const prefix = argumentPrefix.trim();
+    const values = SECURITY_LOG_LIMIT_COMPLETIONS
+        .filter((value) => value.startsWith(prefix))
+        .map((value) => ({ value, label: value, description: `Show ${value} events` }));
+    return values.length > 0 ? values : null;
+}
 function auditAndGateToolCall(api, event, ctx) {
     const logger = getLogger(ctx);
     const toolName = event.toolName;
@@ -97,107 +124,138 @@ function auditAndGateToolCall(api, event, ctx) {
     }
 }
 export default function securityAuditExtension(api) {
+    const showDashboard = (ctx) => {
+        const logger = getLogger(ctx);
+        const stats = logger.getStats();
+        const logs = logger.query({ limit: 20 });
+        let content = `# 🔒 Security Audit\n\n`;
+        content += `## Statistics\n`;
+        content += `- Total Events: ${stats.totalEvents}\n`;
+        content += `- Dangerous: ${stats.byLevel.dangerous}\n`;
+        content += `- Warnings: ${stats.byLevel.warning}\n`;
+        content += `- Blocked: ${stats.byStatus.blocked}\n\n`;
+        if (stats.dangerousPatterns.length > 0) {
+            content += `## Dangerous Patterns\n`;
+            for (const p of stats.dangerousPatterns.slice(0, 5)) {
+                content += `- \`${p.pattern}\`: ${p.count}\n`;
+            }
+            content += `\n`;
+        }
+        content += `## Recent Events\n`;
+        content += `| Time | Type | Level | Target |\n`;
+        content += `|------|------|-------|--------|\n`;
+        for (const log of logs) {
+            const time = log.timestamp.split("T")[1].split(".")[0];
+            content += `| ${time} | ${log.type} | ${log.level} | \`${log.target.slice(0, 30)}...\` |\n`;
+        }
+        api.sendMessage({
+            customType: SECURITY_MESSAGE_TYPE,
+            content,
+            display: true,
+        }, { triggerTurn: false });
+    };
+    const showLogs = (args, ctx) => {
+        const logger = getLogger(ctx);
+        const limit = parseInt(args) || 50;
+        const logs = logger.query({ limit });
+        let content = `# Security Audit Logs (${logs.length} entries)\n\n`;
+        for (const log of logs) {
+            const icon = log.status === "blocked" ? "🔴" : log.level === "dangerous" ? "⚠️" : "✅";
+            content += `${icon} [${log.timestamp}] ${log.type}: ${log.operation}\n`;
+            content += `   Target: ${log.target}\n`;
+            content += `   Level: ${log.level}, Status: ${log.status}\n`;
+            if (log.reason) {
+                content += `   Reason: ${log.reason}\n`;
+            }
+            content += "\n";
+        }
+        api.sendMessage({
+            customType: SECURITY_MESSAGE_TYPE,
+            content,
+            display: true,
+        }, { triggerTurn: false });
+    };
+    const showStats = (ctx) => {
+        const logger = getLogger(ctx);
+        const stats = logger.getStats();
+        let content = `# Security Statistics\n\n`;
+        content += `## Overview\n`;
+        content += `- Period: ${stats.periodStart.split("T")[0]} ~ ${stats.periodEnd.split("T")[0]}\n`;
+        content += `- Total Events: ${stats.totalEvents}\n\n`;
+        content += `## By Level\n`;
+        content += `- Safe: ${stats.byLevel.safe}\n`;
+        content += `- Warning: ${stats.byLevel.warning}\n`;
+        content += `- Dangerous: ${stats.byLevel.dangerous}\n\n`;
+        content += `## By Status\n`;
+        content += `- Allowed: ${stats.byStatus.allowed}\n`;
+        content += `- Blocked: ${stats.byStatus.blocked}\n`;
+        content += `- Confirmed: ${stats.byStatus.confirmed}\n\n`;
+        if (stats.dangerousPatterns.length > 0) {
+            content += `## Dangerous Patterns\n`;
+            for (const p of stats.dangerousPatterns) {
+                content += `- \`${p.pattern}\`: ${p.count}\n`;
+            }
+        }
+        api.sendMessage({
+            customType: SECURITY_MESSAGE_TYPE,
+            content,
+            display: true,
+        }, { triggerTurn: false });
+    };
+    const clearLogs = (ctx) => {
+        const logger = getLogger(ctx);
+        logger.clear();
+        api.sendMessage({
+            customType: SECURITY_MESSAGE_TYPE,
+            content: "✅ Security audit logs cleared.",
+            display: true,
+        }, { triggerTurn: false });
+    };
     // /security - Show security dashboard
     api.registerCommand("security", {
-        description: "Show security audit dashboard and logs",
-        handler: async (_args, ctx) => {
-            const logger = getLogger(ctx);
-            const stats = logger.getStats();
-            const logs = logger.query({ limit: 20 });
-            let content = `# 🔒 Security Audit\n\n`;
-            content += `## Statistics\n`;
-            content += `- Total Events: ${stats.totalEvents}\n`;
-            content += `- Dangerous: ${stats.byLevel.dangerous}\n`;
-            content += `- Warnings: ${stats.byLevel.warning}\n`;
-            content += `- Blocked: ${stats.byStatus.blocked}\n\n`;
-            if (stats.dangerousPatterns.length > 0) {
-                content += `## Dangerous Patterns\n`;
-                for (const p of stats.dangerousPatterns.slice(0, 5)) {
-                    content += `- \`${p.pattern}\`: ${p.count}\n`;
-                }
-                content += `\n`;
-            }
-            content += `## Recent Events\n`;
-            content += `| Time | Type | Level | Target |\n`;
-            content += `|------|------|-------|--------|\n`;
-            for (const log of logs) {
-                const time = log.timestamp.split("T")[1].split(".")[0];
-                content += `| ${time} | ${log.type} | ${log.level} | \`${log.target.slice(0, 30)}...\` |\n`;
+        description: "Review security activity, logs, stats, or clear saved events",
+        getArgumentCompletions: getSecurityArgumentCompletions,
+        handler: async (args, ctx) => {
+            const [action, ...rest] = args.trim().split(/\s+/);
+            switch (action) {
+                case "":
+                case "dashboard":
+                    showDashboard(ctx);
+                    return;
+                case "logs":
+                    showLogs(rest.join(" "), ctx);
+                    return;
+                case "stats":
+                    showStats(ctx);
+                    return;
+                case "clear":
+                    clearLogs(ctx);
+                    return;
+                default:
+                    ctx.ui.notify("Usage: /security [dashboard|logs|stats|clear]", "info");
             }
-            api.sendMessage({
-                customType: SECURITY_MESSAGE_TYPE,
-                content,
-                display: true,
-            }, { triggerTurn: false });
         },
     });
     // /security-logs - Show detailed logs
     api.registerCommand("security-logs", {
-        description: "Show detailed security audit logs",
+        description: "Show detailed security event history",
+        getArgumentCompletions: getSecurityLogLimitCompletions,
         handler: async (args, ctx) => {
-            const logger = getLogger(ctx);
-            const limit = parseInt(args) || 50;
-            const logs = logger.query({ limit });
-            let content = `# Security Audit Logs (${logs.length} entries)\n\n`;
-            for (const log of logs) {
-                const icon = log.status === "blocked" ? "🔴" : log.level === "dangerous" ? "⚠️" : "✅";
-                content += `${icon} [${log.timestamp}] ${log.type}: ${log.operation}\n`;
-                content += `   Target: ${log.target}\n`;
-                content += `   Level: ${log.level}, Status: ${log.status}\n`;
-                if (log.reason) {
-                    content += `   Reason: ${log.reason}\n`;
-                }
-                content += "\n";
-            }
-            api.sendMessage({
-                customType: SECURITY_MESSAGE_TYPE,
-                content,
-                display: true,
-            }, { triggerTurn: false });
+            showLogs(args, ctx);
         },
     });
     // /security-stats - Show statistics
     api.registerCommand("security-stats", {
-        description: "Show security audit statistics",
+        description: "Show security event counts",
         handler: async (_args, ctx) => {
-            const logger = getLogger(ctx);
-            const stats = logger.getStats();
-            let content = `# Security Statistics\n\n`;
-            content += `## Overview\n`;
-            content += `- Period: ${stats.periodStart.split("T")[0]} ~ ${stats.periodEnd.split("T")[0]}\n`;
-            content += `- Total Events: ${stats.totalEvents}\n\n`;
-            content += `## By Level\n`;
-            content += `- Safe: ${stats.byLevel.safe}\n`;
-            content += `- Warning: ${stats.byLevel.warning}\n`;
-            content += `- Dangerous: ${stats.byLevel.dangerous}\n\n`;
-            content += `## By Status\n`;
-            content += `- Allowed: ${stats.byStatus.allowed}\n`;
-            content += `- Blocked: ${stats.byStatus.blocked}\n`;
-            content += `- Confirmed: ${stats.byStatus.confirmed}\n\n`;
-            if (stats.dangerousPatterns.length > 0) {
-                content += `## Dangerous Patterns\n`;
-                for (const p of stats.dangerousPatterns) {
-                    content += `- \`${p.pattern}\`: ${p.count}\n`;
-                }
-            }
-            api.sendMessage({
-                customType: SECURITY_MESSAGE_TYPE,
-                content,
-                display: true,
-            }, { triggerTurn: false });
+            showStats(ctx);
         },
     });
     // /security-clear - Clear logs
     api.registerCommand("security-clear", {
-        description: "Clear security audit logs",
+        description: "Clear saved security events",
         handler: async (_args, ctx) => {
-            const logger = getLogger(ctx);
-            logger.clear();
-            api.sendMessage({
-                customType: SECURITY_MESSAGE_TYPE,
-                content: "✅ Security audit logs cleared.",
-                display: true,
-            }, { triggerTurn: false });
+            clearLogs(ctx);
         },
     });
     // Tool call is the authoritative pre-execution boundary. Returning

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

@@ -8,6 +8,17 @@ import { Box, Container, Spacer, Text } from "@pencil-agent/tui";
 import { SubAgentRunner } from "./subagent-runner.js";
 import { buildSubAgentHelp, parseSubAgentCommand } from "./subagent-parser.js";
 const SUBAGENT_MESSAGE_TYPE = "subagent";
+const SUBAGENT_ROOT_COMPLETIONS = [
+    { value: "run", label: "run", description: "Start a background helper task" },
+    { value: "stop", label: "stop", description: "Stop the current helper task" },
+    { value: "status", label: "status", description: "Show current helper task status" },
+    { value: "report", label: "report", description: "Show the latest helper report" },
+    { value: "apply", label: "apply", description: "Copy isolated changes into this workspace" },
+    { value: "help", label: "help", description: "Show helper commands" },
+];
+const SUBAGENT_RUN_COMPLETIONS = [
+    { value: "--write", label: "--write", description: "Allow changes in an isolated workspace" },
+];
 // Global runner instance
 let runner = null;
 let lastReport = null;
@@ -36,6 +47,7 @@ export default async function subagentExtension(api) {
     for (const commandName of commandNames) {
         api.registerCommand(commandName, {
             description: getCommandDescription(commandName),
+            getArgumentCompletions: (argumentPrefix, context) => getArgumentCompletions(commandName, argumentPrefix, context),
             handler: async (args, ctx) => {
                 const parsed = parseSubAgentCommand(commandName, args);
                 if (!parsed) {
@@ -172,19 +184,31 @@ export default async function subagentExtension(api) {
         });
     }
 }
+function getArgumentCompletions(commandName, argumentPrefix, context) {
+    if (commandName === "subagent:run" && context && context.tokenIndex > 0)
+        return null;
+    const prefix = argumentPrefix.trim().toLowerCase();
+    const values = commandName === "subagent"
+        ? SUBAGENT_ROOT_COMPLETIONS
+        : commandName === "subagent:run"
+            ? SUBAGENT_RUN_COMPLETIONS
+            : [];
+    const matches = values.filter((value) => value.value.startsWith(prefix));
+    return matches.length > 0 ? matches.map((value) => ({ ...value })) : null;
+}
 function getCommandDescription(commandName) {
     switch (commandName) {
         case "subagent:run":
-            return "Run a SubAgent task (/subagent:run <task> [--write])";
+            return "Start a background helper task (/subagent:run <task> [--write])";
         case "subagent:stop":
-            return "Stop the active SubAgent run";
+            return "Stop the active background helper task";
         case "subagent:status":
-            return "Show current SubAgent run status";
+            return "Show current background helper status";
         case "subagent:report":
-            return "Show the latest SubAgent report";
+            return "Show the latest background helper report";
         case "subagent:apply":
             return "Apply the latest isolated write run to the main workspace";
         default:
-            return "SubAgent orchestration help";
+            return "Run or inspect a background helper task";
     }
 }

package/dist/extensions/defaults/team/index.js

@@ -23,7 +23,7 @@
  *   /team:mode <name> <plan|execute|review> - Switch mode
  */
 import { TeamRuntime } from "./team-runtime.js";
-import { buildTeamHelp, parseTeamCommand } from "./team-parser.js";
+import { buildTeamHelp, getTeamArgumentCompletions, parseTeamCommand } from "./team-parser.js";
 import { executePreset, formatPresetResult } from "./team-presets.js";
 import { formatHarnessProgress } from "./team-harness.js";
 import { formatPsycheWeights } from "./team-psyche.js";
@@ -77,6 +77,7 @@ export default async function teamExtension(api) {
     for (const commandName of commandNames) {
         api.registerCommand(commandName, {
             description: getCommandDescription(commandName),
+            getArgumentCompletions: (argumentPrefix, context) => getTeamArgumentCompletions(commandName, argumentPrefix, context),
             handler: async (args, ctx) => {
                 const parsed = parseTeamCommand(commandName, args);
                 if (!parsed) {
@@ -594,32 +595,32 @@ function getCommandDescription(commandName) {
         case "team:spawn":
             return "Create a persistent teammate (/team:spawn <role> [--name <name>])";
         case "team:send":
-            return "Send message to a teammate (/team:send <name> <message>)";
+            return "Send work or a note to a teammate (/team:send <name> <message>)";
         case "team:status":
             return "Show team or teammate status";
         case "team:stop":
             return "Stop teammate's current turn";
         case "team:terminate":
-            return "Destroy a teammate";
+            return "Remove a teammate";
         case "team:approve":
-            return "Approve a permission request";
+            return "Approve a teammate request";
         case "team:mode":
-            return "Switch teammate mode (/team:mode <name> <plan|execute|review>)";
+            return "Change how a teammate works (/team:mode <name> <plan|execute|review>)";
         case "team:preset":
             return "Create teammates from a preset";
         case "team:dashboard":
             return "Toggle the team dashboard";
         case "team:progress":
-            return "Show harness progress";
+            return "Show teammate progress";
         case "team:psyche":
-            return "Show psyche weights";
+            return "Show teammate decision settings";
         case "team:task":
             return "Manage shared team tasks";
         case "team:mail":
-            return "Route teammate-to-teammate mailbox messages";
+            return "Send a note from one teammate to another";
         case "team:allow-path":
             return "Grant a teammate write access to a path prefix";
         default:
-            return "AgentTeam management";
+            return "Create or manage teammates";
     }
 }

package/dist/extensions/defaults/team/team-parser.d.ts

@@ -56,6 +56,23 @@ export interface ParsedTeamCommand {
     /** For allow-path: path prefix */
     path?: string;
 }
+export declare const TEAM_ROOT_COMPLETIONS: readonly ["help", "spawn", "send", "status", "stop", "terminate", "approve", "mode", "preset", "dashboard", "progress", "psyche", "task", "mail", "allow-path"];
+export declare const VALID_ROLES: TeammateRole[];
+export declare const VALID_MODES: TeammateMode[];
+export declare const VALID_PRESETS: PresetName[];
+export declare const VALID_TASK_ACTIONS: readonly ["add", "claim", "done", "block", "cancel", "list"];
+type TeamArgumentCompletionContext = {
+    commandName: string;
+    argumentText: string;
+    argumentPrefix: string;
+    tokenIndex: number;
+    previousTokens: string[];
+};
+export declare function getTeamArgumentCompletions(commandName: string, argumentPrefix: string, context?: TeamArgumentCompletionContext): Array<{
+    value: string;
+    label: string;
+    description?: string;
+}> | null;
 /**
  * Parse a /team command invocation.
  */
@@ -64,3 +81,4 @@ export declare function parseTeamCommand(commandName: string, args?: string): Pa
  * Build help text for /team commands.
  */
 export declare function buildTeamHelp(): string;
+export {};

package/dist/extensions/defaults/team/team-parser.js

@@ -21,7 +21,24 @@
  *   /team:approve <request-id>       - Approve permission request
  *   /team:mode <name> <plan|execute|review> - Switch mode
  */
-const VALID_ROLES = [
+export const TEAM_ROOT_COMPLETIONS = [
+    "help",
+    "spawn",
+    "send",
+    "status",
+    "stop",
+    "terminate",
+    "approve",
+    "mode",
+    "preset",
+    "dashboard",
+    "progress",
+    "psyche",
+    "task",
+    "mail",
+    "allow-path",
+];
+export const VALID_ROLES = [
     "pm",
     "architect",
     "developer",
@@ -34,8 +51,79 @@ const VALID_ROLES = [
     "verifier",
     "generic",
 ];
-const VALID_MODES = ["research", "plan", "execute", "review"];
-const VALID_PRESETS = ["solo", "duo", "squad"];
+export const VALID_MODES = ["research", "plan", "execute", "review"];
+export const VALID_PRESETS = ["solo", "duo", "squad"];
+export const VALID_TASK_ACTIONS = ["add", "claim", "done", "block", "cancel", "list"];
+const TEAM_SPAWN_FLAGS = ["--name", "--harness"];
+const TEAM_COMPLETION_DESCRIPTIONS = {
+    help: "Show team commands",
+    spawn: "Create a teammate",
+    send: "Send work to a teammate",
+    status: "Show teammate status",
+    stop: "Stop a teammate's current turn",
+    terminate: "Remove a teammate",
+    approve: "Approve a teammate request",
+    mode: "Change how a teammate works",
+    preset: "Start with a preset team shape",
+    dashboard: "Show or hide the team panel",
+    progress: "Show teammate progress",
+    psyche: "Show teammate decision settings",
+    task: "Manage shared team tasks",
+    mail: "Send a teammate-to-teammate note",
+    "allow-path": "Allow a teammate to write in a path",
+    pm: "Plan priorities and coordinate work",
+    architect: "Design structure and break down trade-offs",
+    developer: "Have a teammate write code",
+    designer: "Review product and interaction details",
+    "data-analyst": "Check evidence, metrics, and results",
+    researcher: "Explore read-only context",
+    reviewer: "Review code or plans without writing",
+    implementer: "Have a teammate write code",
+    planner: "Have a teammate make a plan",
+    verifier: "Check whether the work is correct",
+    generic: "Use a flexible teammate role",
+    "--name": "Choose the teammate name",
+    "--harness": "Use structured progress tracking",
+    research: "Read and investigate without writing",
+    plan: "Write a plan before code changes",
+    execute: "Allow code changes",
+    review: "Review without writing",
+    solo: "Use one focused teammate",
+    duo: "Use two teammates with complementary roles",
+    squad: "Use a larger team for broader work",
+    add: "Add a shared task",
+    claim: "Assign a task to a teammate",
+    done: "Mark a task complete",
+    block: "Mark a task blocked",
+    cancel: "Cancel a task",
+    list: "List shared tasks",
+};
+function getTeamCompletionValues(commandName, context) {
+    switch (commandName) {
+        case "team":
+            return !context || context.tokenIndex === 0 ? TEAM_ROOT_COMPLETIONS : [];
+        case "team:spawn":
+            if (!context)
+                return [...VALID_ROLES, ...TEAM_SPAWN_FLAGS];
+            return context.tokenIndex === 0 ? VALID_ROLES : TEAM_SPAWN_FLAGS;
+        case "team:preset":
+            return !context || context.tokenIndex === 0 ? VALID_PRESETS : [];
+        case "team:task":
+            return !context || context.tokenIndex === 0 ? VALID_TASK_ACTIONS : [];
+        case "team:mode":
+            return context?.tokenIndex === 1 ? VALID_MODES : [];
+        default:
+            return [];
+    }
+}
+export function getTeamArgumentCompletions(commandName, argumentPrefix, context) {
+    const prefix = argumentPrefix.trim().toLowerCase();
+    const values = getTeamCompletionValues(commandName, context);
+    const matches = values.filter((value) => value.startsWith(prefix));
+    return matches.length > 0
+        ? matches.map((value) => ({ value, label: value, description: TEAM_COMPLETION_DESCRIPTIONS[value] }))
+        : null;
+}
 /**
  * Parse a /team command invocation.
  */

package/dist/extensions/defaults/team/team-ui.js

@@ -11,12 +11,8 @@ import { renderTeamDashboard, renderTeamFooterStatus } from "./team-dashboard.js
 import { formatPsycheWeights } from "./team-psyche.js";
 export const TEAM_MESSAGE_TYPE = "team";
 let dashboardVisible = false;
-let dashboardAutoHideTimer;
 export function clearTeamDashboardTimer() {
-    if (dashboardAutoHideTimer) {
-        clearTimeout(dashboardAutoHideTimer);
-        dashboardAutoHideTimer = undefined;
-    }
+    // Kept for the extension shutdown contract; dashboard visibility is now explicit.
 }
 export function createTeamMessageRenderer() {
     return (message, _options, theme) => {
@@ -129,15 +125,9 @@ export function toggleTeamDashboard(ctx, teamRuntime) {
 export function updateTeamUi(ctx, teamRuntime) {
     const teammates = teamRuntime.getAllTeammates();
     const hasRunning = teammates.some((teammate) => teammate.status === "running");
-    clearTeamDashboardTimer();
-    ctx.ui.setStatus("team", renderTeamFooterStatus(teammates));
-    ctx.ui.setWidget("team-dashboard", dashboardVisible || hasRunning || teammates.length > 0 ? renderTeamDashboard(teammates, 80, { expanded: dashboardVisible }) : undefined);
-    if (!dashboardVisible && !hasRunning && teammates.length > 0) {
-        dashboardAutoHideTimer = setTimeout(() => {
-            ctx.ui.setWidget("team-dashboard", undefined);
-            dashboardAutoHideTimer = undefined;
-        }, 30_000);
-    }
+    const shouldShowTeamUi = dashboardVisible || hasRunning;
+    ctx.ui.setStatus("team", shouldShowTeamUi ? renderTeamFooterStatus(teammates) : undefined);
+    ctx.ui.setWidget("team-dashboard", shouldShowTeamUi ? renderTeamDashboard(teammates, 80, { expanded: dashboardVisible }) : undefined);
 }
 export function setTeamActivity(ctx, lines) {
     const [firstLine] = lines;

package/dist/extensions/defaults/token-save/index.js

@@ -4,6 +4,12 @@ import { applyTokenSavePlan } from "./runner.js";
 import { planCommand } from "./rewrite.js";
 import { applyTomlStyleFilter } from "./toml-dsl.js";
 import { TokenSaveTracker } from "./tracking.js";
+const TOKENSAVE_COMMAND_COMPLETIONS = [
+    { value: "summary", label: "summary", description: "Show total shell output savings" },
+    { value: "history", label: "history", description: "Show recent shortened commands" },
+    { value: "reload", label: "reload", description: "Reload project output-shortening rules" },
+    { value: "plan", label: "plan", description: "Preview how a command will be shortened" },
+];
 function getTextContent(event) {
     const parts = event.content.filter((part) => part.type === "text");
     if (parts.length === 0)
@@ -29,7 +35,14 @@ export default function tokenSaveExtension(api) {
         configuredFilters = filters;
     });
     api.registerCommand("tokensave", {
-        description: "Show TokenSave token savings for this session (/tokensave [summary|history|plan <cmd>])",
+        description: "Review shell output shortening. Usage: /tokensave [summary|history|reload|plan <cmd>]",
+        getArgumentCompletions: (argumentPrefix, context) => {
+            if (context && context.tokenIndex > 0)
+                return null;
+            const prefix = argumentPrefix.trim().toLowerCase();
+            const values = TOKENSAVE_COMMAND_COMPLETIONS.filter((value) => value.value.startsWith(prefix));
+            return values.length > 0 ? values : null;
+        },
         async handler(args, ctx) {
             const trimmed = args.trim();
             if (trimmed === "reload") {

package/dist/extensions/optional/export-html/index.js

@@ -16,6 +16,13 @@ import { SessionManager } from "../../../core/session/session-manager.js";
 import { APP_NAME, getExportTemplateDir } from "../../../config.js";
 import { getResolvedThemeColors, getThemeExportColors } from "../../../modes/interactive/theme/theme.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const EXPORT_COMMAND_COMPLETIONS = [
+    {
+        value: "./nanopencil-session.html",
+        label: "./nanopencil-session.html",
+        description: "Choose the output file for this session export",
+    },
+];
 // Re-export core functions for use by AgentSession
 export { exportSessionToHtml, exportFromFile } from "../../../core/export-html/index.js";
 /**
@@ -239,16 +246,23 @@ export async function extExportFromFile(inputPath, options) {
 export default async function exportHtmlExtension(api) {
     // Register /export command
     api.registerCommand("export", {
-        description: "Export session to HTML file",
-        handler: async (_args, ctx) => {
+        description: "Save this session as a shareable HTML file",
+        getArgumentCompletions: (argumentPrefix, context) => {
+            if (context && context.tokenIndex > 0)
+                return null;
+            const prefix = argumentPrefix.trim().toLowerCase();
+            const values = EXPORT_COMMAND_COMPLETIONS.filter((item) => item.value.startsWith(prefix));
+            return values.length > 0 ? values : null;
+        },
+        handler: async (args, ctx) => {
             // Get session manager from context
             const sessionManager = ctx.sessionManager;
             if (!sessionManager) {
                 throw new Error("Session manager not available");
             }
-            // Export the session (use default output path)
-            // Pass undefined for state since we don't have access to it here
-            const filePath = await extExportSessionToHtml(sessionManager, undefined);
+            const outputPath = args.trim() || undefined;
+            // Pass undefined for state since we don't have access to it here.
+            const filePath = await extExportSessionToHtml(sessionManager, undefined, outputPath);
             console.error(`Session exported to: ${filePath}`);
         },
     });

package/dist/extensions/optional/simplify/index.js

@@ -17,6 +17,10 @@ import { existsSync, readFileSync, writeFileSync } from "fs";
 import { isAbsolute, join, relative, resolve } from "path";
 import { DynamicBorder } from "../../../modes/interactive/components/dynamic-border.js";
 import { getMarkdownTheme } from "../../../modes/interactive/theme/theme.js";
+const SIMPLIFY_COMMAND_COMPLETIONS = [
+    { value: "--dry-run", label: "--dry-run", description: "Preview changes without writing files" },
+    { value: "--no-test", label: "--no-test", description: "Skip the verification command after applying changes" },
+];
 // =============================================================================
 // Git Utilities
 // =============================================================================
@@ -416,11 +420,13 @@ async function executeSimplify(options, ctx) {
 // =============================================================================
 export default function simplifyExtension(api) {
     api.registerCommand("simplify", {
-        description: "Simplify code to reduce cognitive load (Claude Code style)",
-        getArgumentCompletions: (prefix) => {
-            // Could add file completions here
-            const options = ["--dry-run", "--no-test"];
-            return options.filter((o) => o.startsWith(prefix)).map((o) => ({ value: o, label: o }));
+        description: "Suggest smaller code changes for files you choose",
+        getArgumentCompletions: (prefix, context) => {
+            if (context && context.tokenIndex > 0)
+                return null;
+            const normalizedPrefix = prefix.trim().toLowerCase();
+            const options = SIMPLIFY_COMMAND_COMPLETIONS.filter((item) => item.value.startsWith(normalizedPrefix));
+            return options.length > 0 ? options : null;
         },
         handler: async (args, ctx) => {
             const parts = args.trim().split(/\s+/).filter(Boolean);