min-agent 0.1.4 → 0.1.5

package/dist/agent.js

@@ -7,9 +7,11 @@ import { initMcp, shutdownMcp, getMcpTools, loadMcpConfig, getMcpStatus } from "
 import { discoverSkills, getSkillsTool, getSkillsSystemPrompt, getSkills } from "./skills.js";
 import { loadInstructions } from "./instructions.js";
 import { getMemorySystemPrompt, getMemoryTools } from "./memory.js";
-import { needsCompaction, compactMessages, estimateTokens } from "./compaction.js";
+import { needsCompaction, compactMessages, estimateTokens, TokenTracker } from "./compaction.js";
 import { loadPluginTools } from "./plugins.js";
 import { MarkdownRenderer } from "./markdown.js";
+import { DoomLoopDetector } from "./doom-loop.js";
+import { scanProject, buildCodeSystemPrompt } from "./code-mode.js";
 import { ThinkingBodySplitter, stripThinkingFromAssistantText } from "./assistant-stream.js";
 import { printHeader, printDivider, printToolCall, printToolResult, printDone } from "./output.js";
 import readline from "readline";
@@ -109,7 +111,8 @@ export async function runAgent(message, modelId, imagePaths) {
     console.log(`\x1b[36m> ${message}\x1b[0m\n`);
     const content = await buildUserContent(message, imagePaths);
     const messages = [{ role: "user", content }];
-    await runOnce(messages, instructions, modelId);
+    const tracker = new TokenTracker();
+    await runOnce(messages, instructions, modelId, undefined, undefined, tracker);
     await shutdownMcp();
 }
 /** Interactive multi-turn chat session */
@@ -123,6 +126,7 @@ export async function runChat(modelId, resumeSessionId) {
     printInitReady();
     let messages = [];
     let sessionId = resumeSessionId;
+    const tracker = new TokenTracker();
     // Resume existing session
     if (resumeSessionId) {
         const { loadSession } = await import("./sessions.js");
@@ -144,7 +148,7 @@ export async function runChat(modelId, resumeSessionId) {
         if (abortController) {
             abortController.abort();
             abortController = null;
-            console.log("\n\x1b[90m(interrupted)\x1b[0m\n");
+            console.log("\n\x1b[90m(cancelled)\x1b[0m\n");
             rl.prompt();
         }
         else {
@@ -163,24 +167,34 @@ export async function runChat(modelId, resumeSessionId) {
         }
         // Handle slash commands
         if (input.startsWith("/")) {
-            const handled = await handleSlashCommand(input, messages, instructions, modelId, rl);
+            const handled = await handleSlashCommand(input, messages, instructions, modelId, rl, tracker);
             if (handled === "exit")
                 break;
+            if (handled === "paste") {
+                console.log();
+                abortController = new AbortController();
+                await runOnce(messages, instructions, modelId, abortController.signal, undefined, tracker);
+                abortController = null;
+                console.log();
+                rl.prompt();
+                continue;
+            }
             rl.prompt();
             continue;
         }
         console.log();
         messages.push({ role: "user", content: input });
         abortController = new AbortController();
-        await runOnce(messages, instructions, modelId, abortController.signal);
+        await runOnce(messages, instructions, modelId, abortController.signal, undefined, tracker);
         abortController = null;
         console.log();
         rl.prompt();
     }
-    // Auto-save session on exit
+    // Auto-save session on exit with LLM-generated title
     if (messages.length > 0) {
-        const { saveSession } = await import("./sessions.js");
-        sessionId = saveSession(messages, sessionId);
+        const { saveSessionWithTitle } = await import("./sessions.js");
+        const model = resolveModel(modelId);
+        sessionId = await saveSessionWithTitle(messages, model, sessionId);
         console.log(`\x1b[90m  Session saved: ${sessionId}\x1b[0m`);
     }
     rl.close();
@@ -188,7 +202,297 @@ export async function runChat(modelId, resumeSessionId) {
     console.log("\x1b[90mBye!\x1b[0m");
     await shutdownMcp();
 }
-async function handleSlashCommand(input, messages, instructions, modelId, rl) {
+/** AI Coding mode: project-aware interactive session */
+export async function runCode(modelId, resumeSessionId) {
+    printHeader(modelId);
+    console.log("\x1b[90m  Mode: code\x1b[0m");
+    printDivider();
+    // Scan project
+    console.log("\x1b[90m⟳ Scanning project...\x1b[0m");
+    const project = scanProject();
+    console.log(`\x1b[90m  ${project.languages.join(", ") || "Unknown language"}${project.framework ? ` (${project.framework})` : ""} | ${project.isGitRepo ? `git:${project.branch}` : "no git"}\x1b[0m`);
+    await initMcp();
+    discoverSkills();
+    const instructions = await loadInstructions();
+    const codePrompt = buildCodeSystemPrompt(project, instructions);
+    console.log("\x1b[90m✓ Ready\x1b[0m");
+    let messages = [];
+    let sessionId = resumeSessionId;
+    const tracker = new TokenTracker();
+    if (resumeSessionId) {
+        const { loadSession } = await import("./sessions.js");
+        const session = loadSession(resumeSessionId);
+        if (session) {
+            messages = session.messages;
+            sessionId = resumeSessionId;
+            console.log(`\x1b[90m  Resumed: ${session.meta.title} (${messages.length} msgs)\x1b[0m`);
+        }
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: "\x1b[32m❯ \x1b[0m",
+    });
+    let abortController = null;
+    process.on("SIGINT", () => {
+        if (abortController) {
+            abortController.abort();
+            abortController = null;
+            console.log("\n\x1b[90m(cancelled)\x1b[0m\n");
+            rl.prompt();
+        }
+        else {
+            console.log();
+            rl.close();
+        }
+    });
+    console.log("\x1b[90m输入任务开始编码，/help 查看命令，Ctrl+C 中断\x1b[0m\n");
+    rl.prompt();
+    for await (const line of rl) {
+        const input = line.trim();
+        if (!input) {
+            rl.prompt();
+            continue;
+        }
+        if (input.startsWith("/")) {
+            const handled = await handleSlashCommand(input, messages, [codePrompt], modelId, rl, tracker);
+            if (handled === "exit")
+                break;
+            if (handled === "paste") {
+                console.log();
+                abortController = new AbortController();
+                await runOnceWithSystem(messages, codePrompt, modelId, abortController.signal, undefined, tracker);
+                abortController = null;
+                console.log();
+                rl.prompt();
+                continue;
+            }
+            rl.prompt();
+            continue;
+        }
+        console.log();
+        messages.push({ role: "user", content: input });
+        abortController = new AbortController();
+        // Use code system prompt instead of generic one
+        await runOnceWithSystem(messages, codePrompt, modelId, abortController.signal, undefined, tracker);
+        abortController = null;
+        console.log();
+        rl.prompt();
+    }
+    if (messages.length > 0) {
+        const { saveSessionWithTitle } = await import("./sessions.js");
+        const model = resolveModel(modelId);
+        sessionId = await saveSessionWithTitle(messages, model, sessionId);
+        console.log(`\x1b[90m  Session saved: ${sessionId}\x1b[0m`);
+    }
+    rl.close();
+    printDivider();
+    console.log("\x1b[90mBye!\x1b[0m");
+    await shutdownMcp();
+}
+/** runOnce variant that accepts a pre-built system prompt (for code mode) */
+export async function runOnceWithSystem(messages, systemPrompt, modelId, abortSignal, callbacks, tracker) {
+    const model = resolveModel(modelId);
+    const api = !!callbacks;
+    if (needsCompaction(messages, tracker)) {
+        console.log("\x1b[90m⟳ Compacting context...\x1b[0m");
+        const result = await compactMessages(messages, model);
+        if (result.compacted) {
+            messages.length = 0;
+            messages.push(...result.messages);
+            if (result.shouldContinue) {
+                messages.push({ role: "user", content: "Continue with your task." });
+            }
+            if (tracker)
+                tracker.resetContext();
+            console.log(`\x1b[90m  ✓ Compacted (${estimateTokens(messages)} tokens estimated)\x1b[0m`);
+        }
+    }
+    const builtinTools = createTools();
+    const mcpTools = getMcpTools();
+    const memoryTools = getMemoryTools();
+    const pluginTools = await loadPluginTools();
+    const { createTaskTool } = await import("./tools/task.js");
+    const { createExploreTool } = await import("./tools/explore.js");
+    const skills = getSkills();
+    const allTools = { ...builtinTools, ...memoryTools, ...pluginTools };
+    for (const [id, t] of Object.entries(mcpTools))
+        allTools[id] = t;
+    if (skills.length > 0)
+        allTools["skill"] = getSkillsTool();
+    allTools["task"] = createTaskTool(modelId);
+    allTools["explore"] = createExploreTool(modelId);
+    let stepCount = 0;
+    let hasError = false;
+    const doomLoop = new DoomLoopDetector();
+    const result = streamText({
+        model,
+        system: systemPrompt,
+        messages,
+        tools: allTools,
+        stopWhen: stepCountIs(MAX_STEPS),
+        maxRetries: 3,
+        abortSignal,
+        onStepFinish() { stepCount++; },
+        onError() { },
+    });
+    Promise.resolve(result.usage).catch(() => { });
+    let rawText = "";
+    let assistantText = "";
+    const md = new MarkdownRenderer();
+    const thinkingSplit = new ThinkingBodySplitter();
+    try {
+        for await (const event of result.fullStream) {
+            switch (event.type) {
+                case "text-delta": {
+                    const { display, thinking } = thinkingSplit.feed(event.text);
+                    if (thinking) {
+                        if (callbacks?.onThinkingDelta)
+                            callbacks.onThinkingDelta(thinking);
+                        else
+                            writeThinkingDelta(thinking);
+                    }
+                    if (display) {
+                        rawText += display;
+                        assistantText += display;
+                        if (callbacks?.onAssistantDisplayDelta)
+                            callbacks.onAssistantDisplayDelta(display);
+                        else {
+                            const formatted = md.write(display);
+                            if (formatted)
+                                process.stdout.write(formatted);
+                        }
+                    }
+                    break;
+                }
+                case "tool-call": {
+                    if (doomLoop.record(event.toolName, event.input)) {
+                        const warn = `Doom loop detected: "${event.toolName}" — breaking.`;
+                        if (callbacks?.onStreamError)
+                            callbacks.onStreamError(warn);
+                        else
+                            console.log(`\n\x1b[33m⚠ ${warn}\x1b[0m`);
+                        hasError = true;
+                        break;
+                    }
+                    const flush = thinkingSplit.flush();
+                    if (flush.thinking) {
+                        if (callbacks?.onThinkingDelta)
+                            callbacks.onThinkingDelta(flush.thinking);
+                        else
+                            writeThinkingDelta(flush.thinking);
+                    }
+                    if (flush.display) {
+                        rawText += flush.display;
+                        assistantText += flush.display;
+                        if (callbacks?.onAssistantDisplayDelta)
+                            callbacks.onAssistantDisplayDelta(flush.display);
+                        else {
+                            const extra = md.write(flush.display);
+                            if (extra)
+                                process.stdout.write(extra);
+                        }
+                    }
+                    if (!api) {
+                        const flushed = md.flush();
+                        if (flushed)
+                            process.stdout.write(flushed);
+                        if (rawText.trim())
+                            console.log();
+                    }
+                    rawText = "";
+                    if (callbacks?.onToolCall)
+                        callbacks.onToolCall(event.toolName, event.input);
+                    else
+                        printToolCall(event.toolName, event.input);
+                    break;
+                }
+                case "tool-result":
+                    if (callbacks?.onToolResult)
+                        callbacks.onToolResult(event.toolName, event.output);
+                    else
+                        printToolResult(event.toolName, event.output);
+                    break;
+                case "error":
+                    hasError = true;
+                    if (callbacks?.onStreamError)
+                        callbacks.onStreamError(String(event.error));
+                    else
+                        console.error(`\x1b[31mError: ${event.error}\x1b[0m`);
+                    break;
+                case "finish":
+                    break;
+            }
+        }
+        const end = thinkingSplit.flush();
+        if (end.thinking) {
+            if (callbacks?.onThinkingDelta)
+                callbacks.onThinkingDelta(end.thinking);
+            else
+                writeThinkingDelta(end.thinking);
+        }
+        if (end.display) {
+            assistantText += end.display;
+            if (callbacks?.onAssistantDisplayDelta)
+                callbacks.onAssistantDisplayDelta(end.display);
+            else {
+                const tail = md.write(end.display);
+                if (tail)
+                    process.stdout.write(tail);
+            }
+        }
+        if (!api) {
+            const remaining = md.flush();
+            if (remaining)
+                process.stdout.write(remaining);
+            if (rawText.trim())
+                console.log();
+        }
+        const cleaned = stripThinkingFromAssistantText(assistantText);
+        if (cleaned.trim())
+            messages.push({ role: "assistant", content: cleaned });
+        let usage;
+        try {
+            usage = await result.usage;
+        }
+        catch {
+            usage = undefined;
+        }
+        if (usage && tracker)
+            tracker.update(usage);
+        if (callbacks?.onRunFinish) {
+            callbacks.onRunFinish({ stepCount, usage, hasError, aborted: false });
+        }
+        else {
+            if (!hasError && usage) {
+                printDivider();
+                const { getContextWindow } = await import("./context-window.js");
+                const ctxWindow = await getContextWindow(modelId);
+                printDone(stepCount, usage, ctxWindow);
+            }
+            else {
+                printDivider();
+            }
+        }
+    }
+    catch (err) {
+        if (err.name === "AbortError" || abortSignal?.aborted) {
+            const cleaned = stripThinkingFromAssistantText(assistantText);
+            if (cleaned.trim())
+                messages.push({ role: "assistant", content: cleaned });
+            if (callbacks?.onRunFinish)
+                callbacks.onRunFinish({ stepCount, usage: undefined, hasError: false, aborted: true });
+            return;
+        }
+        if (callbacks?.onStreamError)
+            callbacks.onStreamError(err.message);
+        else {
+            printDivider();
+            console.error(`\x1b[31mError: ${err.message}\x1b[0m`);
+        }
+    }
+}
+async function handleSlashCommand(input, messages, instructions, modelId, rl, tracker) {
     const [cmd, ...rest] = input.slice(1).split(/\s+/);
     const arg = rest.join(" ");
     switch (cmd) {
@@ -207,9 +511,11 @@ async function handleSlashCommand(input, messages, instructions, modelId, rl) {
             else {
                 console.log("\x1b[90m  ⟳ Compacting...\x1b[0m");
                 const model = resolveModel(modelId);
-                const result = await compactMessages(messages, model, { keepRecentTurns: 2 });
+                const result = await compactMessages(messages, model, { keepRecentTurns: 2, autoContinue: false });
                 messages.length = 0;
                 messages.push(...result.messages);
+                if (tracker)
+                    tracker.resetContext();
                 console.log(`\x1b[90m  ✓ Compacted (${estimateTokens(messages)} tokens estimated)\x1b[0m`);
             }
             return "handled";
@@ -305,10 +611,41 @@ async function handleSlashCommand(input, messages, instructions, modelId, rl) {
             }
             return "handled";
         }
-        case "tokens":
-            console.log(`\x1b[90m  Estimated tokens in context: ${estimateTokens(messages)}\x1b[0m`);
+        case "tokens": {
+            if (tracker && tracker.lastInputTokens > 0) {
+                const { getContextWindow } = await import("./context-window.js");
+                const ctxWindow = await getContextWindow(modelId);
+                const pct = Math.round((tracker.lastInputTokens / ctxWindow) * 100);
+                console.log(`\x1b[90m  Context: ${tracker.lastInputTokens} / ${ctxWindow} tokens (${pct}%)\x1b[0m`);
+                console.log(`\x1b[90m  Total: ${tracker.totalInputTokens} in / ${tracker.totalOutputTokens} out\x1b[0m`);
+            }
+            else {
+                console.log(`\x1b[90m  Estimated tokens in context: ${estimateTokens(messages)}\x1b[0m`);
+            }
             console.log(`\x1b[90m  Messages: ${messages.length}\x1b[0m`);
             return "handled";
+        }
+        case "path":
+        case "pwd":
+            console.log(`\x1b[90m  ${process.cwd()}\x1b[0m`);
+            return "handled";
+        case "paste": {
+            const { getClipboardImage } = await import("./clipboard.js");
+            const img = getClipboardImage();
+            if (!img) {
+                console.log("\x1b[90m  No image found in clipboard\x1b[0m");
+                return "handled";
+            }
+            console.log(`\x1b[90m  📎 Clipboard image (${(img.data.length / 1024).toFixed(1)} KB)\x1b[0m`);
+            const text = arg || "What's in this image?";
+            const content = [
+                { type: "text", text },
+                { type: "image", image: img.data, mimeType: img.mimeType },
+            ];
+            messages.push({ role: "user", content });
+            // Return a special signal to trigger runOnce
+            return "paste";
+        }
         case "help":
             console.log(`\x1b[90m  Slash commands:
   /clear          Clear conversation history
@@ -319,6 +656,8 @@ async function handleSlashCommand(input, messages, instructions, modelId, rl) {
   /skills         List discovered skills
   /mcp            List MCP servers and connection status
   /tokens         Show estimated token usage
+  /path           Show current working directory
+  /paste [text]   Paste clipboard image + optional prompt
   /help           Show this help
   /exit           Exit the chat\x1b[0m`);
             return "handled";
@@ -327,11 +666,11 @@ async function handleSlashCommand(input, messages, instructions, modelId, rl) {
             return "handled";
     }
 }
-export async function runOnce(messages, instructions, modelId, abortSignal, callbacks) {
+export async function runOnce(messages, instructions, modelId, abortSignal, callbacks, tracker) {
     const model = resolveModel(modelId);
     const api = !!callbacks;
     // Auto-compact if context is getting too large
-    if (needsCompaction(messages)) {
+    if (needsCompaction(messages, tracker)) {
         if (api) {
             callbacks.onCompaction?.("compacting_start");
         }
@@ -342,6 +681,15 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
         if (result.compacted) {
             messages.length = 0;
             messages.push(...result.messages);
+            // Auto-continue: inject a message so the agent keeps working
+            if (result.shouldContinue) {
+                messages.push({
+                    role: "user",
+                    content: "Continue if you have next steps, or stop and ask for clarification if you are unsure how to proceed.",
+                });
+            }
+            if (tracker)
+                tracker.resetContext();
             if (api) {
                 callbacks.onCompaction?.(`compacted_ok estimated_tokens=${estimateTokens(messages)}`);
             }
@@ -350,11 +698,12 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
             }
         }
     }
-    // Merge all tools: builtin + MCP + skill + memory + plugins
+    // Merge all tools: builtin + MCP + skill + memory + plugins + task
     const builtinTools = createTools();
     const mcpTools = getMcpTools();
     const memoryTools = getMemoryTools();
     const pluginTools = await loadPluginTools();
+    const { createTaskTool } = await import("./tools/task.js");
     const skills = getSkills();
     const allTools = { ...builtinTools, ...memoryTools, ...pluginTools };
     for (const [id, t] of Object.entries(mcpTools)) {
@@ -363,8 +712,10 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
     if (skills.length > 0) {
         allTools["skill"] = getSkillsTool();
     }
+    allTools["task"] = createTaskTool(modelId);
     let stepCount = 0;
     let hasError = false;
+    const doomLoop = new DoomLoopDetector();
     const result = streamText({
         model,
         system: buildSystemPrompt(instructions),
@@ -411,6 +762,16 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
                     break;
                 }
                 case "tool-call": {
+                    // Doom loop detection
+                    if (doomLoop.record(event.toolName, event.input)) {
+                        const warning = `\x1b[33m⚠ Doom loop detected: "${event.toolName}" called ${3} times with same args. Breaking loop.\x1b[0m`;
+                        if (callbacks?.onStreamError)
+                            callbacks.onStreamError(warning);
+                        else
+                            console.log(`\n${warning}`);
+                        hasError = true;
+                        break;
+                    }
                     const splitFlush = thinkingSplit.flush();
                     emitThinking(splitFlush.thinking);
                     if (splitFlush.display) {
@@ -492,6 +853,10 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
         catch {
             usage = undefined;
         }
+        // Update token tracker with real usage from API
+        if (usage && tracker) {
+            tracker.update(usage);
+        }
         if (callbacks?.onRunFinish) {
             callbacks.onRunFinish({ stepCount, usage, hasError, aborted: false });
         }
@@ -501,7 +866,9 @@ export async function runOnce(messages, instructions, modelId, abortSignal, call
                 return;
             }
             printDivider();
-            printDone(stepCount, usage);
+            const { getContextWindow } = await import("./context-window.js");
+            const ctxWindow = await getContextWindow(modelId);
+            printDone(stepCount, usage, ctxWindow);
         }
     }
     catch (err) {

package/dist/cli.js

@@ -24,6 +24,7 @@ Usage:
   min-agent chat <message>          Send a message to the agent
   min-agent chat                    Start interactive multi-turn chat
   min-agent chat --resume <id>      Resume a previous session
+  min-agent code                    AI coding mode (project-aware)
   min-agent setup                   Configure API provider (interactive)
   min-agent models                  List available models
   min-agent history                 List saved sessions
@@ -159,7 +160,6 @@ async function main() {
             }
             const message = chatArgs.join(" ");
             if (!message) {
-                // No message provided — enter interactive multi-turn mode
                 await runChat(modelOverride, resumeId);
             }
             else {
@@ -167,6 +167,25 @@ async function main() {
             }
             break;
         }
+        case "code": {
+            if (!isConfigured()) {
+                console.error("Not configured. Run: min-agent setup");
+                process.exit(1);
+            }
+            let modelOverride;
+            let resumeId;
+            for (let i = 1; i < args.length; i++) {
+                if ((args[i] === "--model" || args[i] === "-m") && args[i + 1]) {
+                    modelOverride = args[++i];
+                }
+                else if (args[i] === "--resume" && args[i + 1]) {
+                    resumeId = args[++i];
+                }
+            }
+            const { runCode } = await import("./agent.js");
+            await runCode(modelOverride, resumeId);
+            break;
+        }
         case "serve": {
             if (!isConfigured()) {
                 console.error("Not configured. Run: min-agent setup");

package/dist/clipboard.js

@@ -0,0 +1,106 @@
+import { execSync } from "child_process";
+import path from "path";
+import os from "os";
+export function getClipboardImage() {
+    switch (process.platform) {
+        case "darwin":
+            return getClipboardImageMac();
+        case "linux":
+            return getClipboardImageLinux();
+        case "win32":
+            return getClipboardImageWindows();
+        default:
+            return null;
+    }
+}
+function getClipboardImageMac() {
+    const tmpFile = path.join(os.tmpdir(), `min-agent-paste-${Date.now()}.png`);
+    try {
+        // Try pngpaste first (brew install pngpaste)
+        execSync(`pngpaste "${tmpFile}" 2>/dev/null`, { stdio: "pipe" });
+        const { readFileSync } = require("fs");
+        const data = readFileSync(tmpFile);
+        try {
+            require("fs").unlinkSync(tmpFile);
+        }
+        catch { }
+        if (data.length > 0)
+            return { data, mimeType: "image/png" };
+    }
+    catch { }
+    try {
+        // Fallback: osascript to save clipboard image
+        const script = `
+      set tmpFile to POSIX file "${tmpFile}"
+      try
+        set imgData to the clipboard as «class PNGf»
+        set fp to open for access tmpFile with write permission
+        write imgData to fp
+        close access fp
+        return "ok"
+      on error
+        return "no_image"
+      end try
+    `;
+        const result = execSync(`osascript -e '${script.replace(/'/g, "'\\''")}'`, { encoding: "utf-8" }).trim();
+        if (result === "ok") {
+            const { readFileSync, unlinkSync } = require("fs");
+            const data = readFileSync(tmpFile);
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { }
+            if (data.length > 0)
+                return { data, mimeType: "image/png" };
+        }
+    }
+    catch { }
+    return null;
+}
+function getClipboardImageLinux() {
+    try {
+        // xclip
+        const data = execSync("xclip -selection clipboard -t image/png -o 2>/dev/null", {
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        if (data.length > 0)
+            return { data, mimeType: "image/png" };
+    }
+    catch { }
+    try {
+        // xsel fallback
+        const data = execSync("xsel --clipboard --output 2>/dev/null", {
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        // Check if it's actually image data (PNG magic bytes)
+        if (data.length > 8 && data[0] === 0x89 && data[1] === 0x50) {
+            return { data, mimeType: "image/png" };
+        }
+    }
+    catch { }
+    return null;
+}
+function getClipboardImageWindows() {
+    const tmpFile = path.join(os.tmpdir(), `min-agent-paste-${Date.now()}.png`);
+    try {
+        const ps = `
+      Add-Type -AssemblyName System.Windows.Forms
+      $img = [System.Windows.Forms.Clipboard]::GetImage()
+      if ($img) { $img.Save('${tmpFile.replace(/\\/g, "\\\\")}', [System.Drawing.Imaging.ImageFormat]::Png); Write-Output 'ok' }
+      else { Write-Output 'no_image' }
+    `;
+        const result = execSync(`powershell -NoProfile -Command "${ps}"`, { encoding: "utf-8" }).trim();
+        if (result === "ok") {
+            const { readFileSync, unlinkSync } = require("fs");
+            const data = readFileSync(tmpFile);
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { }
+            if (data.length > 0)
+                return { data, mimeType: "image/png" };
+        }
+    }
+    catch { }
+    return null;
+}