@llmtune/cli 0.1.2 → 0.1.5

package/README.md

@@ -6,10 +6,10 @@ AI CLI Agent for your terminal, powered by [llmtune.io](https://llmtune.io).
 
 ```bash
 # Install globally
-npm install -g llmtune
+npm install -g @llmtune/cli
 
 # Or run directly
-npx llmtune
+npx @llmtune/cli
 
 # Configure your API key
 llmtune login

package/dist/agent/loop.d.ts

@@ -1,12 +1,17 @@
 import OpenAI from "openai";
 import { ToolRegistry } from "../tools/registry";
 import { Conversation } from "./conversation";
+import { PermissionManager } from "../tools/permissions";
 export interface AgentLoopConfig {
     model?: string;
     maxTurns?: number;
     verbose?: boolean;
+    stream?: boolean;
     cwd: string;
     workspaceRoot: string;
+    permissions?: PermissionManager;
+    /** When true, skip adding userInput (already in conversation). */
+    skipUserInput?: boolean;
 }
 export interface AgentLoopResult {
     finalText: string;

package/dist/agent/loop.js

@@ -5,11 +5,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runAgentLoop = runAgentLoop;
 const builder_1 = require("../context/builder");
+const auto_compact_1 = require("../compact/auto-compact");
+const service_1 = require("../memory/service");
+const tokens_1 = require("../utils/tokens");
 const chalk_1 = __importDefault(require("chalk"));
 async function runAgentLoop(client, conversation, registry, userInput, config, onTextChunk) {
     const model = config.model ?? "z-ai/GLM-5.1";
     const maxTurns = config.maxTurns ?? 20;
-    conversation.addUserMessage(userInput);
+    const useStream = config.stream !== false;
+    if (!config.skipUserInput) {
+        conversation.addUserMessage(userInput);
+        (0, service_1.saveActiveTask)(userInput);
+    }
     const toolSpecs = registry.listSpecs();
     const openaiTools = toolSpecs.map((spec) => ({
         type: "function",
@@ -19,102 +26,35 @@ async function runAgentLoop(client, conversation, registry, userInput, config, o
             parameters: spec.inputSchema,
         },
     }));
-    const contextResult = await (0, builder_1.buildContextPrompt)(config.workspaceRoot, config.cwd);
-    const contextPrompt = contextResult.prompt;
+    const contextResult = await (0, builder_1.buildContextPrompt)(config.workspaceRoot, config.cwd, {
+        model: config.model,
+    });
+    const memoryPrompt = (0, service_1.buildMemoryPrompt)();
+    const contextPrompt = memoryPrompt
+        ? `${contextResult.prompt}\n\n${memoryPrompt}`
+        : contextResult.prompt;
+    const toolSchemaTokens = (0, tokens_1.estimateTokens)(JSON.stringify(toolSpecs));
+    await (0, auto_compact_1.maybeAutoCompact)({
+        client,
+        model,
+        conversation,
+        systemPrompt: contextPrompt,
+        toolSchemaTokens,
+    });
     let totalToolCalls = 0;
     let totalTokensIn = 0;
     let totalTokensOut = 0;
     let turns = 0;
     let finalText = "";
     for (let turn = 0; turn < maxTurns; turn++) {
-        const apiMessages = conversation.getApiMessages();
-        const systemMessage = {
-            role: "system",
-            content: contextPrompt,
-        };
-        const allMessages = [
-            systemMessage,
-            ...apiMessages.map((msg) => {
-                if (msg.role === "system")
-                    return { role: "system", content: msg.content };
-                if (msg.role === "user")
-                    return { role: "user", content: msg.content };
-                if (msg.role === "assistant") {
-                    const m = {
-                        role: "assistant",
-                        content: msg.content || null,
-                    };
-                    if (msg.toolCalls && msg.toolCalls.length > 0) {
-                        m.tool_calls = msg.toolCalls.map((tc) => ({
-                            id: tc.id,
-                            type: "function",
-                            function: { name: tc.function.name, arguments: tc.function.arguments },
-                        }));
-                    }
-                    return m;
-                }
-                if (msg.role === "tool") {
-                    return {
-                        role: "tool",
-                        tool_call_id: msg.toolCallId ?? "",
-                        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
-                    };
-                }
-                return { role: "user", content: msg.content };
-            }),
-        ];
-        const stream = await client.chat.completions.create({
-            model,
-            messages: allMessages,
-            tools: openaiTools.length > 0 ? openaiTools : undefined,
-            stream: true,
-            temperature: 0.7,
-            max_tokens: 16384,
-        });
-        let assistantContent = "";
-        const toolCalls = [];
-        let currentToolCall = null;
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta;
-            if (!delta)
-                continue;
-            if (delta.content) {
-                assistantContent += delta.content;
-                if (onTextChunk)
-                    onTextChunk(delta.content);
-                else
-                    process.stdout.write(delta.content);
-            }
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    if (tc.id && tc.function?.name) {
-                        currentToolCall = {
-                            id: tc.id,
-                            name: tc.function.name,
-                            arguments: tc.function.arguments ?? "",
-                        };
-                        toolCalls.push({
-                            id: tc.id,
-                            type: "function",
-                            function: { name: tc.function.name, arguments: tc.function.arguments ?? "" },
-                        });
-                    }
-                    else if (currentToolCall && tc.function?.arguments) {
-                        currentToolCall.arguments += tc.function.arguments;
-                        const last = toolCalls[toolCalls.length - 1];
-                        if (last)
-                            last.function.arguments = currentToolCall.arguments;
-                    }
-                }
-            }
-            if (chunk.usage) {
-                totalTokensIn += chunk.usage.prompt_tokens ?? 0;
-                totalTokensOut += chunk.usage.completion_tokens ?? 0;
-            }
-        }
-        if (!onTextChunk)
-            console.log();
+        const allMessages = buildApiMessages(conversation, contextPrompt);
+        const turnResult = useStream
+            ? await runStreamingTurn(client, model, allMessages, openaiTools, onTextChunk)
+            : await runBufferedTurn(client, model, allMessages, openaiTools);
+        totalTokensIn += turnResult.tokensIn;
+        totalTokensOut += turnResult.tokensOut;
         turns++;
+        const { assistantContent, toolCalls } = turnResult;
         if (toolCalls.length === 0) {
             conversation.addAssistantMessage(assistantContent);
             finalText = assistantContent;
@@ -132,6 +72,18 @@ async function runAgentLoop(client, conversation, registry, userInput, config, o
             }
             const summary = summarizeToolInput(tc.function.name, toolInput);
             console.log(chalk_1.default.cyan(`  ▶ ${tc.function.name}`) + chalk_1.default.dim(` ${summary}`));
+            if (config.permissions) {
+                const tool = registry.get(tc.function.name);
+                const spec = tool?.spec();
+                const isDestructive = spec?.isDestructive === true;
+                const perm = await config.permissions.check(tc.function.name, toolInput, isDestructive);
+                if (perm.behavior === "deny") {
+                    const denyMsg = perm.message ?? "User denied tool execution";
+                    console.log(chalk_1.default.yellow(`  ⊘ ${tc.function.name}: ${denyMsg}`));
+                    conversation.addToolResult(tc.id, `Denied: ${denyMsg}`);
+                    continue;
+                }
+            }
             const toolCtx = {
                 workspaceRoot: config.workspaceRoot,
                 cwd: config.cwd,
@@ -152,6 +104,130 @@ async function runAgentLoop(client, conversation, registry, userInput, config, o
     }
     return { finalText, totalToolCalls, totalTokensIn, totalTokensOut, turns };
 }
+function buildApiMessages(conversation, contextPrompt) {
+    const systemMessage = {
+        role: "system",
+        content: contextPrompt,
+    };
+    return [
+        systemMessage,
+        ...conversation.getApiMessages().map((msg) => {
+            if (msg.role === "system")
+                return { role: "system", content: msg.content };
+            if (msg.role === "user")
+                return { role: "user", content: msg.content };
+            if (msg.role === "assistant") {
+                const m = {
+                    role: "assistant",
+                    content: msg.content || null,
+                };
+                if (msg.toolCalls && msg.toolCalls.length > 0) {
+                    m.tool_calls = msg.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.function.name, arguments: tc.function.arguments },
+                    }));
+                }
+                return m;
+            }
+            if (msg.role === "tool") {
+                return {
+                    role: "tool",
+                    tool_call_id: msg.toolCallId ?? "",
+                    content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+                };
+            }
+            return { role: "user", content: msg.content };
+        }),
+    ];
+}
+async function runStreamingTurn(client, model, messages, openaiTools, onTextChunk) {
+    const stream = await client.chat.completions.create({
+        model,
+        messages,
+        tools: openaiTools.length > 0 ? openaiTools : undefined,
+        stream: true,
+        temperature: 0.7,
+        max_tokens: 16384,
+    });
+    let assistantContent = "";
+    const toolCalls = [];
+    let currentToolCall = null;
+    let tokensIn = 0;
+    let tokensOut = 0;
+    for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta;
+        if (!delta)
+            continue;
+        if (delta.content) {
+            assistantContent += delta.content;
+            if (onTextChunk)
+                onTextChunk(delta.content);
+            else
+                process.stdout.write(delta.content);
+        }
+        if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+                if (tc.id && tc.function?.name) {
+                    currentToolCall = {
+                        id: tc.id,
+                        name: tc.function.name,
+                        arguments: tc.function.arguments ?? "",
+                    };
+                    toolCalls.push({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.function.name, arguments: tc.function.arguments ?? "" },
+                    });
+                }
+                else if (currentToolCall && tc.function?.arguments) {
+                    currentToolCall.arguments += tc.function.arguments;
+                    const last = toolCalls[toolCalls.length - 1];
+                    if (last)
+                        last.function.arguments = currentToolCall.arguments;
+                }
+            }
+        }
+        if (chunk.usage) {
+            tokensIn += chunk.usage.prompt_tokens ?? 0;
+            tokensOut += chunk.usage.completion_tokens ?? 0;
+        }
+    }
+    if (!onTextChunk)
+        console.log();
+    return { assistantContent, toolCalls, tokensIn, tokensOut };
+}
+async function runBufferedTurn(client, model, messages, openaiTools) {
+    const response = await client.chat.completions.create({
+        model,
+        messages,
+        tools: openaiTools.length > 0 ? openaiTools : undefined,
+        stream: false,
+        temperature: 0.7,
+        max_tokens: 16384,
+    });
+    const choice = response.choices[0];
+    const msg = choice?.message;
+    const assistantContent = msg?.content ?? "";
+    const toolCalls = (msg?.tool_calls ?? []).map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+            name: tc.function.name,
+            arguments: tc.function.arguments ?? "",
+        },
+    }));
+    if (assistantContent) {
+        process.stdout.write(assistantContent);
+        console.log();
+    }
+    return {
+        assistantContent,
+        toolCalls,
+        tokensIn: response.usage?.prompt_tokens ?? 0,
+        tokensOut: response.usage?.completion_tokens ?? 0,
+    };
+}
 function summarizeToolInput(name, input) {
     const n = name.toLowerCase();
     if (n === "bash") {

package/dist/auth/client.js

@@ -7,15 +7,24 @@ exports.createClient = createClient;
 exports.getDefaultModel = getDefaultModel;
 const openai_1 = __importDefault(require("openai"));
 const config_1 = require("./config");
+const version_1 = require("../version");
 function createClient() {
     const apiKey = (0, config_1.loadConfig)().apiKey;
     if (!apiKey) {
         console.error("Not logged in. Run: llmtune login");
         process.exit(1);
     }
+    const cwd = process.cwd();
     return new openai_1.default({
         apiKey,
         baseURL: (0, config_1.getApiBase)(),
+        defaultHeaders: {
+            "X-LLMTune-Client": "cli",
+            "X-LLMTune-CLI-Version": version_1.CLI_VERSION,
+            "X-LLMTune-Context-Managed": "true",
+            "X-Workspace-Root": cwd,
+            "X-CWD": cwd,
+        },
     });
 }
 function getDefaultModel() {

package/dist/compact/auto-compact.d.ts

@@ -0,0 +1,25 @@
+import OpenAI from "openai";
+import { Conversation } from "../agent/conversation";
+import { type CompactResult } from "./service";
+export interface AutoCompactOptions {
+    client: OpenAI;
+    model: string;
+    conversation: Conversation;
+    systemPrompt: string;
+    toolSchemaTokens: number;
+    minMessages?: number;
+}
+export interface AutoCompactResult {
+    compacted: boolean;
+    result?: CompactResult;
+    microcompactTokensSaved: number;
+    estimatedTokens: number;
+    threshold: number;
+}
+export declare function estimateSessionTokens(conversation: Conversation, systemPrompt: string, toolSchemaTokens: number): number;
+/**
+ * Microcompact verbose tool results, then LLM-summarize older messages if still over budget.
+ */
+export declare function maybeAutoCompact(options: AutoCompactOptions): Promise<AutoCompactResult>;
+export declare function printCompactionNotice(result: CompactResult, trigger: "manual" | "auto", activeTask?: string): void;
+//# sourceMappingURL=auto-compact.d.ts.map

package/dist/compact/auto-compact.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateSessionTokens = estimateSessionTokens;
+exports.maybeAutoCompact = maybeAutoCompact;
+exports.printCompactionNotice = printCompactionNotice;
+const chalk_1 = __importDefault(require("chalk"));
+const service_1 = require("./service");
+const microcompact_1 = require("./microcompact");
+const tokens_1 = require("../utils/tokens");
+const budget_1 = require("./budget");
+const service_2 = require("../memory/service");
+function estimateSessionTokens(conversation, systemPrompt, toolSchemaTokens) {
+    const messageTokens = (0, tokens_1.estimateMessagesTokens)(conversation.messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+    })));
+    return (0, tokens_1.estimateTokens)(systemPrompt) + toolSchemaTokens + messageTokens;
+}
+/**
+ * Microcompact verbose tool results, then LLM-summarize older messages if still over budget.
+ */
+async function maybeAutoCompact(options) {
+    const { client, model, conversation, systemPrompt, toolSchemaTokens, minMessages = 8, } = options;
+    const threshold = (0, budget_1.getCompactThreshold)(model);
+    let microcompactTokensSaved = 0;
+    const { compacted: microcompacted, tokensSaved } = (0, microcompact_1.microcompactMessages)(conversation.messages);
+    if (tokensSaved > 0) {
+        conversation.messages.length = 0;
+        conversation.messages.push(...microcompacted);
+        microcompactTokensSaved = tokensSaved;
+    }
+    let estimatedTokens = estimateSessionTokens(conversation, systemPrompt, toolSchemaTokens);
+    if (conversation.messages.length < minMessages || estimatedTokens <= threshold) {
+        return { compacted: false, microcompactTokensSaved, estimatedTokens, threshold };
+    }
+    const activeTask = (0, service_2.getActiveTask)();
+    const result = await (0, service_1.compactConversation)(client, model, conversation, undefined, {
+        trigger: "auto",
+        activeTask,
+    });
+    estimatedTokens = estimateSessionTokens(conversation, systemPrompt, toolSchemaTokens);
+    printCompactionNotice(result, "auto", activeTask);
+    return {
+        compacted: true,
+        result,
+        microcompactTokensSaved,
+        estimatedTokens,
+        threshold,
+    };
+}
+function printCompactionNotice(result, trigger, activeTask) {
+    const label = trigger === "auto" ? "Auto-compacted" : "Compacted";
+    console.log("");
+    console.log(chalk_1.default.yellow(`⚠ ${label}: ${result.preCompactMessages} messages → ${result.postCompactMessages} ` +
+        `(~${result.tokensSaved.toLocaleString()} tokens saved)`));
+    if (activeTask) {
+        console.log(chalk_1.default.dim(`  Active task preserved: "${activeTask.slice(0, 120)}${activeTask.length > 120 ? "..." : ""}"`));
+    }
+    console.log(chalk_1.default.dim("  Use /uncompact to restore full history."));
+    console.log("");
+}
+//# sourceMappingURL=auto-compact.js.map

package/dist/compact/budget.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Model context windows and auto-compaction thresholds for the CLI.
+ */
+export declare const COMPACT_THRESHOLD_RATIO = 0.75;
+export declare const KEEP_TAIL_MESSAGES = 6;
+export declare function getModelContextWindow(model: string): number;
+export declare function getCompactThreshold(model: string): number;
+//# sourceMappingURL=budget.d.ts.map

package/dist/compact/budget.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Model context windows and auto-compaction thresholds for the CLI.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEEP_TAIL_MESSAGES = exports.COMPACT_THRESHOLD_RATIO = void 0;
+exports.getModelContextWindow = getModelContextWindow;
+exports.getCompactThreshold = getCompactThreshold;
+const MODEL_CONTEXT_WINDOWS = {
+    "z-ai/GLM-5.1": 128_000,
+    "z-ai/glm-5.1": 128_000,
+    "gpt-4o": 128_000,
+    "gpt-4o-mini": 128_000,
+    "claude-sonnet-4": 200_000,
+};
+const DEFAULT_CONTEXT_WINDOW = 64_000;
+exports.COMPACT_THRESHOLD_RATIO = 0.75;
+exports.KEEP_TAIL_MESSAGES = 6;
+function getModelContextWindow(model) {
+    const normalized = model.trim().toLowerCase();
+    if (MODEL_CONTEXT_WINDOWS[model])
+        return MODEL_CONTEXT_WINDOWS[model];
+    if (MODEL_CONTEXT_WINDOWS[normalized])
+        return MODEL_CONTEXT_WINDOWS[normalized];
+    const env = process.env.LLMTUNE_CONTEXT_WINDOW;
+    if (env) {
+        const parsed = Number.parseInt(env, 10);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    return DEFAULT_CONTEXT_WINDOW;
+}
+function getCompactThreshold(model) {
+    return Math.floor(getModelContextWindow(model) * exports.COMPACT_THRESHOLD_RATIO);
+}
+//# sourceMappingURL=budget.js.map

package/dist/compact/service.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import { Conversation } from "../agent/conversation";
+import { Conversation, type Message } from "../agent/conversation";
 export interface CompactResult {
     tokensSaved: number;
     preCompactTokens: number;
@@ -7,7 +7,15 @@ export interface CompactResult {
     preCompactMessages: number;
     postCompactMessages: number;
     summary: string;
+    activeTask?: string;
+    trigger: "manual" | "auto";
 }
-export declare function compactConversation(client: OpenAI, model: string, conversation: Conversation, sessionsDir?: string): Promise<CompactResult>;
+export interface CompactOptions {
+    trigger?: "manual" | "auto";
+    activeTask?: string;
+    keepTail?: number;
+}
+export declare function extractActiveTask(messages: Message[]): string;
+export declare function compactConversation(client: OpenAI, model: string, conversation: Conversation, sessionsDir?: string, options?: CompactOptions): Promise<CompactResult>;
 export declare function uncompactConversation(conversation: Conversation, sessionsDir?: string): boolean;
 //# sourceMappingURL=service.d.ts.map

package/dist/compact/service.js

@@ -33,9 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractActiveTask = extractActiveTask;
 exports.compactConversation = compactConversation;
 exports.uncompactConversation = uncompactConversation;
 const tokens_1 = require("../utils/tokens");
+const budget_1 = require("./budget");
+const service_1 = require("../memory/service");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -53,22 +56,55 @@ Include:
 7. Pending Tasks: Tasks explicitly requested but not yet done
 8. Current Work: What was being worked on immediately before this summary
 
+The user's ACTIVE TASK must appear verbatim under "Current Work" and "Pending Tasks" if not finished.
+
 Respond ONLY with plain text. No XML tags. No tool calls.`;
-async function compactConversation(client, model, conversation, sessionsDir) {
+function extractActiveTask(messages) {
+    const userMsgs = messages
+        .filter((m) => m.role === "user")
+        .map((m) => (typeof m.content === "string" ? m.content.trim() : ""))
+        .filter(Boolean);
+    if (userMsgs.length === 0)
+        return "";
+    // Prefer the most recent substantive user message (skip one-word replies)
+    for (let i = userMsgs.length - 1; i >= 0; i--) {
+        const msg = userMsgs[i];
+        if (msg.length >= 12 && !msg.startsWith("/")) {
+            return msg.slice(0, 500);
+        }
+    }
+    return userMsgs[userMsgs.length - 1].slice(0, 500);
+}
+async function compactConversation(client, model, conversation, sessionsDir, options) {
+    const trigger = options?.trigger ?? "manual";
+    const keepTail = options?.keepTail ?? budget_1.KEEP_TAIL_MESSAGES;
     const messages = conversation.messages;
+    const activeTask = options?.activeTask ?? extractActiveTask(messages);
+    if (activeTask) {
+        (0, service_1.saveActiveTask)(activeTask);
+    }
     const preCompactTokens = (0, tokens_1.estimateTokens)(messages.map((m) => (typeof m.content === "string" ? m.content : JSON.stringify(m.content))).join(" "));
     const preCompactCount = messages.length;
-    // Save raw history before compacting
     saveRawHistory(conversation, sessionsDir);
-    // Build context for summary: last N messages
-    const contextMessages = messages.slice(-20);
-    const summaryRequestMessages = contextMessages
-        .filter((m) => m.role !== "system")
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const nonSystem = messages.filter((m) => m.role !== "system");
+    const tailMessages = nonSystem.slice(-keepTail);
+    const messagesToCompact = nonSystem.slice(0, -keepTail);
+    const summarySource = messagesToCompact.length > 0 ? messagesToCompact : nonSystem.slice(0, Math.max(0, nonSystem.length - 2));
+    const summaryRequestMessages = summarySource
+        .filter((m) => m.role === "user" || m.role === "assistant")
+        .slice(-30)
         .map((m) => ({
         role: m.role,
-        content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
+        content: truncateForSummary(m),
     }));
-    summaryRequestMessages.push({ role: "user", content: COMPACT_SYSTEM_PROMPT });
+    const taskBlock = activeTask
+        ? `\n\nCRITICAL — preserve this active task in your summary:\n"${activeTask}"`
+        : "";
+    summaryRequestMessages.push({
+        role: "user",
+        content: `${COMPACT_SYSTEM_PROMPT}${taskBlock}`,
+    });
     let summary = "";
     try {
         const response = await client.chat.completions.create({
@@ -80,24 +116,25 @@ async function compactConversation(client, model, conversation, sessionsDir) {
         summary = response.choices[0]?.message?.content?.trim() ?? "";
     }
     catch {
-        summary = buildFallbackSummary(messages);
+        summary = buildFallbackSummary(messages, activeTask);
     }
     if (!summary) {
-        summary = buildFallbackSummary(messages);
+        summary = buildFallbackSummary(messages, activeTask);
+    }
+    if (activeTask) {
+        summary = `## Active Task\n${activeTask}\n\n${summary}`;
     }
-    // Replace conversation with boundary marker + summary
     const boundaryMsg = {
         role: "system",
-        content: `[COMPACT BOUNDARY] Compacted at ${new Date().toISOString()}. ${preCompactCount} messages summarized. Raw history preserved.`,
+        content: `[COMPACT BOUNDARY] ${trigger === "auto" ? "Auto-compacted" : "Compacted"} at ${new Date().toISOString()}. ` +
+            `${preCompactCount} messages summarized (${tailMessages.length} recent messages kept). Raw history preserved.`,
     };
     const summaryMsg = {
         role: "system",
         content: `## Conversation Summary\n\n${summary}`,
     };
-    // Keep system messages + boundary + summary
-    const systemMessages = messages.filter((m) => m.role === "system" && m === messages[0]);
     conversation.messages.length = 0;
-    conversation.messages.push(...systemMessages, boundaryMsg, summaryMsg);
+    conversation.messages.push(...systemMessages, boundaryMsg, summaryMsg, ...tailMessages);
     const postCompactTokens = (0, tokens_1.estimateTokens)(conversation.messages.map((m) => (typeof m.content === "string" ? m.content : JSON.stringify(m.content))).join(" "));
     const postCompactCount = conversation.messages.length;
     return {
@@ -107,6 +144,8 @@ async function compactConversation(client, model, conversation, sessionsDir) {
         preCompactMessages: preCompactCount,
         postCompactMessages: postCompactCount,
         summary,
+        activeTask: activeTask || undefined,
+        trigger,
     };
 }
 function uncompactConversation(conversation, sessionsDir) {
@@ -125,6 +164,14 @@ function uncompactConversation(conversation, sessionsDir) {
         return false;
     }
 }
+function truncateForSummary(msg) {
+    let text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    if (msg.toolCalls?.length) {
+        const tools = msg.toolCalls.map((tc) => tc.function.name).join(", ");
+        text = `[tools: ${tools}] ${text}`;
+    }
+    return text.length > 3000 ? text.slice(0, 3000) + "\n... (truncated)" : text;
+}
 function saveRawHistory(conversation, sessionsDir) {
     const dir = sessionsDir ?? path.join(os.homedir(), ".llmtune", "sessions");
     if (!fs.existsSync(dir)) {
@@ -135,7 +182,7 @@ function saveRawHistory(conversation, sessionsDir) {
         fs.writeFileSync(rawPath, JSON.stringify({ messages: conversation.messages }, null, 2), "utf-8");
     }
 }
-function buildFallbackSummary(messages) {
+function buildFallbackSummary(messages, activeTask) {
     const userMsgs = messages
         .filter((m) => m.role === "user")
         .map((m) => (typeof m.content === "string" ? m.content.slice(0, 200) : ""))
@@ -143,14 +190,26 @@ function buildFallbackSummary(messages) {
     const toolNames = messages
         .filter((m) => m.role === "assistant" && m.toolCalls)
         .flatMap((m) => m.toolCalls?.map((tc) => tc.function.name) ?? []);
-    const parts = [`Conversation had ${messages.length} messages.`];
+    const parts = [];
+    if (activeTask) {
+        parts.push(`## Active Task\n${activeTask}`);
+    }
+    parts.push(`Conversation had ${messages.length} messages.`);
     if (toolNames.length > 0) {
         const unique = [...new Set(toolNames)];
         parts.push(`Tools used: ${unique.join(", ")}`);
     }
     if (userMsgs.length > 0) {
-        parts.push(`Last user message: ${userMsgs[userMsgs.length - 1].slice(0, 150)}`);
+        parts.push(`Recent user requests:\n${userMsgs.slice(-5).map((m) => `- ${m}`).join("\n")}`);
+    }
+    const allContent = messages
+        .map((m) => (typeof m.content === "string" ? m.content : ""))
+        .join(" ");
+    const fileMatches = allContent.match(/[\w/.\\:-]+\.(ts|tsx|js|jsx|py|rs|go|java|json|yaml|yml|md)/g);
+    if (fileMatches) {
+        const uniqueFiles = [...new Set(fileMatches)].slice(0, 15);
+        parts.push(`Files mentioned: ${uniqueFiles.join(", ")}`);
     }
-    return parts.join("\n");
+    return parts.join("\n\n");
 }
 //# sourceMappingURL=service.js.map

package/dist/context/agent-identity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Core agent identity — prepended to every system prompt so the model
+ * identifies as LLMTune Agent, not Claude/ChatGPT/etc.
+ */
+export declare function buildAgentIdentitySection(model?: string): string;
+//# sourceMappingURL=agent-identity.d.ts.map

package/dist/context/agent-identity.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAgentIdentitySection = buildAgentIdentitySection;
+const version_1 = require("../version");
+/**
+ * Core agent identity — prepended to every system prompt so the model
+ * identifies as LLMTune Agent, not Claude/ChatGPT/etc.
+ */
+function buildAgentIdentitySection(model) {
+    const modelLine = model ? `- Model: ${model} (via llmtune.io)` : "- Models served through llmtune.io (e.g. GLM-5.1)";
+    return [
+        "# LLMTune Agent",
+        "",
+        "You are the **LLMTune Agent** — an AI coding assistant from [llmtune.io](https://llmtune.io).",
+        "",
+        "## Identity (always follow)",
+        `- You are **LLMTune Agent**, running in the LLMTune CLI (v${version_1.CLI_VERSION}).`,
+        "- You are **not** Claude, ChatGPT, Copilot, Cursor, or any product from Anthropic, OpenAI, or Microsoft.",
+        "- When asked who you are, say you are the LLMTune Agent powered by llmtune.io. Never claim another brand or company.",
+        modelLine,
+        "",
+        "## How you work",
+        "- You run locally on the user's machine through `llmtune chat`.",
+        "- You use tools (read, write, edit, bash, glob, grep, web-fetch) to act on the workspace.",
+        "- Follow project instructions in LLMTUNE.md or CLAUDE.md when present.",
+        "",
+        "## Behavior",
+        "- Be concise, direct, and helpful.",
+        "- Use tools to investigate and make changes — do not only describe what you would do.",
+        "- Stay on the user's task; continue from the conversation summary and active task in memory if present.",
+        "- If you see a [COMPACT BOUNDARY] message, treat the summary above it as prior context — do not ask the user to repeat their task unless the summary is empty.",
+    ].join("\n");
+}
+//# sourceMappingURL=agent-identity.js.map

package/dist/context/builder.d.ts

@@ -9,5 +9,6 @@ export declare function readCache(cacheKey: string): ContextResult | null;
 export declare function writeCache(cacheKey: string, result: ContextResult): void;
 export declare function buildContextPrompt(workspaceRoot: string, cwd: string, options?: {
     useCache?: boolean;
+    model?: string;
 }): Promise<ContextResult>;
 //# sourceMappingURL=builder.d.ts.map

package/dist/context/builder.js

@@ -43,6 +43,7 @@ const fs = __importStar(require("fs"));
 const git_context_1 = require("./git-context");
 const workspace_1 = require("./workspace");
 const llmtune_md_1 = require("./llmtune-md");
+const agent_identity_1 = require("./agent-identity");
 const CACHE_DIR = () => {
     const base = process.env.LLMTUNE_CACHE_DIR || path.join(process.env.HOME || process.env.USERPROFILE || "~", ".llmtune", "cache");
     return base;
@@ -86,36 +87,47 @@ function writeCache(cacheKey, result) {
 }
 async function buildContextPrompt(workspaceRoot, cwd, options) {
     const cacheKey = computeCacheKey(workspaceRoot, cwd);
+    const identity = (0, agent_identity_1.buildAgentIdentitySection)(options?.model);
+    let workspaceSections = [];
     if (options?.useCache !== false) {
         const cached = readCache(cacheKey);
-        if (cached)
-            return cached;
+        if (cached) {
+            workspaceSections = cached.sections;
+            return {
+                prompt: [identity, ...workspaceSections].filter(Boolean).join("\n\n"),
+                cacheKey,
+                cacheHit: true,
+                sections: [identity, ...workspaceSections],
+            };
+        }
     }
-    const sections = [];
     // Workspace section (async)
     const workspace = await (0, workspace_1.buildWorkspaceSnapshot)(workspaceRoot, cwd);
     const workspaceSection = (0, workspace_1.renderWorkspaceSection)(workspace);
     if (workspaceSection)
-        sections.push(workspaceSection);
+        workspaceSections.push(workspaceSection);
     // Git section
     const git = (0, git_context_1.collectGitContext)(workspaceRoot);
     const gitSection = renderGitSection(git);
     if (gitSection)
-        sections.push(gitSection);
+        workspaceSections.push(gitSection);
     // LLMTUNE.md / CLAUDE.md section
     const mdFiles = (0, llmtune_md_1.loadProjectInstructions)(workspaceRoot, cwd);
     const mdSection = renderMdSection(mdFiles, workspaceRoot);
     if (mdSection)
-        sections.push(mdSection);
-    const prompt = sections.join("\n\n");
-    const result = {
-        prompt,
+        workspaceSections.push(mdSection);
+    writeCache(cacheKey, {
+        prompt: workspaceSections.join("\n\n"),
+        cacheKey,
+        cacheHit: false,
+        sections: workspaceSections,
+    });
+    return {
+        prompt: [identity, ...workspaceSections].filter(Boolean).join("\n\n"),
         cacheKey,
         cacheHit: false,
-        sections,
+        sections: [identity, ...workspaceSections],
     };
-    writeCache(cacheKey, result);
-    return result;
 }
 function renderGitSection(git) {
     if (!git.available)

package/dist/memory/service.d.ts

@@ -3,6 +3,7 @@ declare const MEMORY_FILES: {
     readonly "project-notes": "project-notes.md";
     readonly decisions: "decisions.md";
     readonly architecture: "architecture.md";
+    readonly "active-task": "active-task.md";
 };
 type MemoryCategory = keyof typeof MEMORY_FILES;
 export interface MemoryEntry {
@@ -15,6 +16,8 @@ export declare function writeMemory(category: MemoryCategory, content: string):
 export declare function appendMemory(category: MemoryCategory, line: string): void;
 export declare function readAllMemory(): MemoryEntry[];
 export declare function buildMemoryPrompt(): string;
+export declare function saveActiveTask(task: string): void;
+export declare function getActiveTask(): string;
 export declare function clearMemory(category?: MemoryCategory): void;
 export declare function getMemoryDir(): string;
 export declare function initMemoryFiles(): void;

package/dist/memory/service.js

@@ -38,6 +38,8 @@ exports.writeMemory = writeMemory;
 exports.appendMemory = appendMemory;
 exports.readAllMemory = readAllMemory;
 exports.buildMemoryPrompt = buildMemoryPrompt;
+exports.saveActiveTask = saveActiveTask;
+exports.getActiveTask = getActiveTask;
 exports.clearMemory = clearMemory;
 exports.getMemoryDir = getMemoryDir;
 exports.initMemoryFiles = initMemoryFiles;
@@ -50,6 +52,7 @@ const MEMORY_FILES = {
     "project-notes": "project-notes.md",
     decisions: "decisions.md",
     architecture: "architecture.md",
+    "active-task": "active-task.md",
 };
 function ensureMemoryDir() {
     if (!fs.existsSync(MEMORY_DIR)) {
@@ -104,6 +107,18 @@ function buildMemoryPrompt() {
     });
     return "## User Memory\n\n" + sections.join("\n\n");
 }
+function saveActiveTask(task) {
+    const trimmed = task.trim();
+    if (!trimmed)
+        return;
+    writeMemory("active-task", `# Active Task\n\n${trimmed}`);
+}
+function getActiveTask() {
+    const raw = readMemory("active-task");
+    if (!raw)
+        return "";
+    return raw.replace(/^#\s*Active Task\s*\n+/i, "").trim();
+}
 function clearMemory(category) {
     if (category) {
         const filePath = getMemoryPath(category);
@@ -135,6 +150,7 @@ function initMemoryFiles() {
         "project-notes": "# Project Notes\n# Key facts about the current project\n# Example: Auth uses JWT + bcrypt\n# Example: Database is Neon PostgreSQL via Prisma\n",
         decisions: "# Architecture Decisions\n# Record important technical decisions\n# Example: Decided to use Prisma instead of Drizzle for ORM\n",
         architecture: "# Architecture Overview\n# Describe the project structure\n# Example: Frontend: Next.js 16, Backend: Express 5, DB: Neon\n",
+        "active-task": "# Active Task\n# Updated automatically from your latest requests\n",
     };
     for (const [category, defaultContent] of Object.entries(defaults)) {
         const filePath = getMemoryPath(category);

package/dist/repl/repl.js

@@ -41,6 +41,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const readline_1 = require("readline");
 const conversation_1 = require("../agent/conversation");
 const registry_1 = require("../tools/registry");
+const permissions_1 = require("../tools/permissions");
 const loop_1 = require("../agent/loop");
 const read_1 = require("../tools/tools/read");
 const write_1 = require("../tools/tools/write");
@@ -51,7 +52,9 @@ const grep_1 = require("../tools/tools/grep");
 const web_fetch_1 = require("../tools/tools/web-fetch");
 const ask_user_1 = require("../tools/tools/ask-user");
 const service_1 = require("../compact/service");
+const auto_compact_1 = require("../compact/auto-compact");
 const analyzer_1 = require("../context/analyzer");
+const builder_1 = require("../context/builder");
 const loader_1 = require("../skills/loader");
 const trust_1 = require("../skills/trust");
 const service_2 = require("../memory/service");
@@ -83,7 +86,7 @@ ${chalk_1.default.bold("LLMTune CLI - Commands:")}
 async function startRepl(options) {
     const registry = new registry_1.ToolRegistry();
     const cwd = process.cwd();
-    const trustedTools = new Set();
+    const permissions = new permissions_1.PermissionManager();
     registry.register(read_1.readTool);
     registry.register(write_1.writeTool);
     registry.register(edit_1.editTool);
@@ -150,16 +153,17 @@ async function startRepl(options) {
                         console.log(chalk_1.default.yellow(`  Warning: tool "${toolName}" not allowed for skill trust level "${trustLevel}"`));
                     }
                 }
-                // Add skill system prompt and user message
                 conversation.addSystemMessage(execution.systemPrompt);
-                conversation.addUserMessage(execution.userMessage);
                 try {
                     const result = await (0, loop_1.runAgentLoop)(options.client, conversation, registry, execution.userMessage, {
                         model: currentModel,
                         maxTurns: 50,
                         verbose,
+                        stream: streamMode,
                         cwd,
                         workspaceRoot: cwd,
+                        permissions,
+                        skipUserInput: false,
                     });
                     (0, logger_1.logEvent)({ event: "tool_call", tool: skillName, latency_ms: 0 });
                 }
@@ -178,7 +182,7 @@ async function startRepl(options) {
                 conversation,
                 registry,
                 skills,
-                trustedTools,
+                permissions,
                 cwd,
                 client: options.client,
                 getModel: () => currentModel,
@@ -203,8 +207,10 @@ async function startRepl(options) {
                 model: currentModel,
                 maxTurns: 50,
                 verbose,
+                stream: streamMode,
                 cwd,
                 workspaceRoot: cwd,
+                permissions,
             });
             if (result.totalTokensIn > 0 || result.totalTokensOut > 0) {
                 const cost = estimateCostFromUsage(result.totalTokensIn, result.totalTokensOut);
@@ -256,8 +262,9 @@ async function handleCommand(input, ctx) {
             console.log(chalk_1.default.green("Conversation cleared."));
             break;
         case "/context": {
+            const ctxResult = await (0, builder_1.buildContextPrompt)(ctx.cwd, ctx.cwd, { model: ctx.getModel() });
             const analysis = (0, analyzer_1.analyzeContextUsage)({
-                systemPrompt: "LLMTune coding agent",
+                systemPrompt: ctxResult.prompt,
                 toolSpecs: ctx.registry.listSpecs(),
                 messages: ctx.conversation.getApiMessages().map((m) => ({
                     role: m.role,
@@ -277,10 +284,12 @@ async function handleCommand(input, ctx) {
             }
             console.log(chalk_1.default.dim("Compacting conversation..."));
             try {
-                const result = await (0, service_1.compactConversation)(ctx.client, ctx.getModel(), ctx.conversation);
-                console.log(chalk_1.default.green(`\nCompacted: ${result.preCompactMessages} -> ${result.postCompactMessages} messages`));
+                const result = await (0, service_1.compactConversation)(ctx.client, ctx.getModel(), ctx.conversation, undefined, {
+                    trigger: "manual",
+                });
+                (0, auto_compact_1.printCompactionNotice)(result, "manual", result.activeTask);
+                console.log(chalk_1.default.green(`Compacted: ${result.preCompactMessages} -> ${result.postCompactMessages} messages`));
                 console.log(chalk_1.default.dim(`  Tokens saved: ~${result.tokensSaved.toLocaleString()}`));
-                console.log(chalk_1.default.dim(`  Use /uncompact to restore full history.`));
                 (0, logger_1.logEvent)({ event: "compaction", tokens_saved: result.tokensSaved, messages_before: result.preCompactMessages, messages_after: result.postCompactMessages, trigger: "manual" });
             }
             catch (err) {
@@ -318,7 +327,7 @@ async function handleCommand(input, ctx) {
             break;
         case "/trust":
             if (args[0]) {
-                ctx.trustedTools.add(args[0].toLowerCase());
+                ctx.permissions.trustTool(args[0].toLowerCase());
                 console.log(chalk_1.default.green(`Trusting tool: ${args[0]} (no confirmation needed)`));
             }
             else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmtune/cli",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "LLMTune CLI -AI CLI Agent powered by llmtune.io",
   "main": "dist/index.js",
   "bin": {
@@ -10,7 +10,8 @@
     "build": "tsc",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
-    "lint": "tsc --noEmit"
+    "lint": "tsc --noEmit",
+    "test": "npm run build && node scripts/smoke-test.js"
   },
   "keywords": ["llmtune", "cli", "ai", "agent", "coding"],
   "license": "MIT",

package/scripts/smoke-test.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * CLI smoke tests — run: npm test
+ * Set LLMTUNE_API_KEY or configure ~/.llmtune/config.json for live API tests.
+ */
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+
+let passed = 0
+let failed = 0
+let skipped = 0
+
+function ok(name) {
+  passed++
+  console.log(`  ✓ ${name}`)
+}
+
+function fail(name, err) {
+  failed++
+  console.log(`  ✗ ${name}: ${err}`)
+}
+
+function skip(name, reason) {
+  skipped++
+  console.log(`  ⊘ ${name} (${reason})`)
+}
+
+function test(name, fn) {
+  try {
+    fn()
+    ok(name)
+  } catch (e) {
+    fail(name, e.message)
+  }
+}
+
+async function testAsync(name, fn) {
+  try {
+    await fn()
+    ok(name)
+  } catch (e) {
+    fail(name, e.message)
+  }
+}
+
+async function main() {
+  console.log("=== LLMTune CLI Smoke Tests ===\n")
+
+  test("dist/index.js exists", () => {
+    const p = path.join(__dirname, "..", "dist", "index.js")
+    if (!fs.existsSync(p)) throw new Error("run npm run build first")
+  })
+
+  test("agent identity module", () => {
+    const { buildAgentIdentitySection } = require("../dist/context/agent-identity")
+    const text = buildAgentIdentitySection("z-ai/GLM-5.1")
+    if (!text.includes("LLMTune Agent")) throw new Error("missing identity")
+    if (text.toLowerCase().includes("you are claude")) throw new Error("should not identify as Claude")
+  })
+
+  test("git context (Windows-safe)", () => {
+    const { collectGitContext } = require("../dist/context/git-context")
+    collectGitContext(process.cwd())
+  })
+
+  test("microcompact", () => {
+    const { microcompactMessages } = require("../dist/compact/microcompact")
+    const { compacted } = microcompactMessages([
+      { role: "tool", content: "x".repeat(5000) },
+    ])
+    if (compacted[0].content.length >= 5000) throw new Error("not compressed")
+  })
+
+  test("context analyzer", () => {
+    const { analyzeContextUsage } = require("../dist/context/analyzer")
+    const a = analyzeContextUsage({
+      systemPrompt: "test",
+      toolSpecs: [],
+      messages: [{ role: "user", content: "hi" }],
+      model: "z-ai/GLM-5.1",
+    })
+    if (a.totalTokens <= 0) throw new Error("expected tokens > 0")
+  })
+
+  test("permission manager trust", () => {
+    const { PermissionManager } = require("../dist/tools/permissions")
+    const pm = new PermissionManager()
+    pm.trustTool("bash")
+    if (!pm.isTrusted("bash")) throw new Error("trust failed")
+  })
+
+  await testAsync("registry dispatchAsync", async () => {
+    const { ToolRegistry } = require("../dist/tools/registry")
+    const { bashTool } = require("../dist/tools/tools/bash")
+    const reg = new ToolRegistry()
+    reg.register(bashTool)
+    await reg.dispatchAsync("bash", { command: "echo SMOKE_OK" }, {
+      workspaceRoot: process.cwd(),
+      cwd: process.cwd(),
+    })
+  })
+
+  const configPath = path.join(os.homedir(), ".llmtune", "config.json")
+  const hasApi = Boolean(process.env.LLMTUNE_API_KEY) || fs.existsSync(configPath)
+
+  if (hasApi) {
+    await testAsync("API agent loop + bash tool", async () => {
+      const { createClient } = require("../dist/auth/client")
+      const { Conversation } = require("../dist/agent/conversation")
+      const { ToolRegistry } = require("../dist/tools/registry")
+      const { bashTool } = require("../dist/tools/tools/bash")
+      const { runAgentLoop } = require("../dist/agent/loop")
+
+      const client = createClient()
+      const registry = new ToolRegistry()
+      registry.register(bashTool)
+      const conversation = new Conversation("z-ai/GLM-5.1")
+      const cwd = process.cwd()
+
+      const result = await runAgentLoop(
+        client,
+        conversation,
+        registry,
+        "Run bash command: echo AGENT_SMOKE_OK. Use bash tool only.",
+        { model: "z-ai/GLM-5.1", maxTurns: 3, stream: false, cwd, workspaceRoot: cwd },
+      )
+
+      if (result.totalToolCalls === 0) throw new Error("expected at least one tool call")
+    })
+  } else {
+    skip("API agent loop + bash tool", "no API key")
+  }
+
+  console.log(`\n=== Results: ${passed} passed, ${failed} failed, ${skipped} skipped ===`)
+  process.exit(failed > 0 ? 1 : 0)
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})