@tspappsen/elamax 1.2.3

package/dist/diagnosis.js

@@ -0,0 +1,79 @@
+/**
+ * Failure taxonomy and structured repair suggestions for worker task failures.
+ * Inspired by the AutoResearchClaw ExperimentDiagnosis pattern.
+ */
+const TAXONOMY = [
+    {
+        type: "timeout",
+        label: "Timeout",
+        pattern: /timeout|timed?\s*out/i,
+        suggestion: "Increase WORKER_TIMEOUT in your Max .env file, or break the task into smaller, faster steps.",
+    },
+    {
+        type: "permission_error",
+        label: "Permission Error",
+        pattern: /permission denied|EACCES|EPERM|not permitted|access denied|unauthorized/i,
+        suggestion: "Check file/directory permissions. You may need elevated privileges or corrected ownership (chmod/chown).",
+    },
+    {
+        type: "network_error",
+        label: "Network Error",
+        pattern: /ECONNREFUSED|ECONNRESET|ENOTFOUND|socket hang up|fetch failed|getaddrinfo|connect ETIMEDOUT|EHOSTUNREACH/i,
+        suggestion: "Check your network connection, firewall rules, or proxy settings. The remote service may be temporarily unavailable.",
+    },
+    {
+        type: "file_not_found",
+        label: "File Not Found",
+        pattern: /ENOENT|no such file or directory|file not found|cannot find module|MODULE_NOT_FOUND/i,
+        suggestion: "Verify the file or directory path exists. If a module is missing, run the relevant install command (npm install, pip install, etc.).",
+    },
+    {
+        type: "dependency_error",
+        label: "Dependency Error",
+        pattern: /npm ERR|yarn error|pip.*error|no module named|package not found|unresolved dependency/i,
+        suggestion: "Install missing dependencies with the relevant package manager (npm install, pip install, cargo build, etc.).",
+    },
+    {
+        type: "syntax_error",
+        label: "Syntax Error",
+        pattern: /SyntaxError|syntax error|unexpected token|parse error|invalid syntax/i,
+        suggestion: "Review the code for syntax mistakes — mismatched brackets, missing semicolons, or invalid expressions.",
+    },
+    {
+        type: "config_error",
+        label: "Configuration Error",
+        pattern: /missing.*key|invalid.*key|API key|token.*invalid|credentials|auth.*failed|configuration.*error|invalid.*config/i,
+        suggestion: "Check your configuration files and environment variables. Ensure all required keys and credentials are set correctly.",
+    },
+    {
+        type: "logic_error",
+        label: "Logic Error",
+        pattern: /assertion.*failed|AssertionError|TypeError|ReferenceError|undefined is not|null is not|cannot read prop|NaN|stack overflow/i,
+        suggestion: "Review the task logic and the full error trace. Consider simplifying the prompt or splitting the task into smaller, verifiable steps.",
+    },
+];
+/** Classify an error message into a named failure type with a targeted repair suggestion. */
+export function diagnoseFailure(errorMessage) {
+    for (const entry of TAXONOMY) {
+        if (entry.pattern.test(errorMessage)) {
+            return { type: entry.type, label: entry.label, suggestion: entry.suggestion };
+        }
+    }
+    return {
+        type: "unknown",
+        label: "Unknown Error",
+        suggestion: "Review the full error output. If the problem persists, try restarting Max or breaking the task into smaller steps.",
+    };
+}
+/** Format a failure diagnosis as a structured, readable report for the orchestrator. */
+export function formatDiagnosedFailure(workerName, elapsed, errorMessage) {
+    const diagnosis = diagnoseFailure(errorMessage);
+    return [
+        `⚠️ Worker '${workerName}' failed after ${elapsed}s`,
+        ``,
+        `Failure type: ${diagnosis.label}`,
+        `Error: ${errorMessage}`,
+        `Suggestion: ${diagnosis.suggestion}`,
+    ].join("\n");
+}
+//# sourceMappingURL=diagnosis.js.map

package/dist/discord/bot.js

@@ -0,0 +1,505 @@
+import { Client, GatewayIntentBits, Events, REST, Routes, SlashCommandBuilder, ThreadAutoArchiveDuration, } from "discord.js";
+import { createWriteStream } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { pipeline } from "node:stream/promises";
+import { config, persistModel } from "../config.js";
+import { sendToOrchestrator, cancelCurrentMessage, getWorkers, getLastRouteResult, invalidateSession, } from "../copilot/orchestrator.js";
+import { chunkMessage } from "./formatter.js";
+import { searchMemories } from "../store/db.js";
+import { listSkills } from "../copilot/skills.js";
+import { restartDaemon } from "../daemon.js";
+import { getRouterConfig, updateRouterConfig } from "../copilot/router.js";
+let client;
+const commands = [
+    new SlashCommandBuilder().setName("help").setDescription("Show help"),
+    new SlashCommandBuilder().setName("cancel").setDescription("Cancel the current message"),
+    new SlashCommandBuilder()
+        .setName("model")
+        .setDescription("Show or switch the AI model")
+        .addStringOption((opt) => opt.setName("name").setDescription("Model name to switch to").setRequired(false)),
+    new SlashCommandBuilder().setName("auto").setDescription("Toggle auto model routing"),
+    new SlashCommandBuilder().setName("memory").setDescription("Show stored memories"),
+    new SlashCommandBuilder().setName("skills").setDescription("List installed skills"),
+    new SlashCommandBuilder().setName("workers").setDescription("List active worker sessions"),
+    new SlashCommandBuilder().setName("restart").setDescription("Restart Max"),
+];
+function getHelpText() {
+    return ("I'm Max, your AI daemon.\n\n" +
+        "Send a message in an allowed guild channel and I'll handle it. You can also attach images for analysis.\n\n" +
+        "Commands:\n" +
+        "/cancel — Cancel the current message\n" +
+        "/model — Show current model\n" +
+        "/model name:<name> — Switch model\n" +
+        "/auto — Toggle auto model routing\n" +
+        "/memory — Show stored memories\n" +
+        "/skills — List installed skills\n" +
+        "/workers — List active worker sessions\n" +
+        "/restart — Restart Max\n" +
+        "/help — Show this help");
+}
+function isAllowedChannel(channelId) {
+    return config.discordAllowedChannelIds.includes(channelId);
+}
+async function sendDiscordInteractionResponse(interaction, text) {
+    const chunks = chunkMessage(text);
+    for (let i = 0; i < chunks.length; i++) {
+        if (i === 0) {
+            if (interaction.deferred || interaction.replied) {
+                await interaction.editReply(chunks[i]);
+            }
+            else {
+                await interaction.reply(chunks[i]);
+            }
+        }
+        else {
+            await interaction.followUp(chunks[i]);
+        }
+    }
+}
+async function sendDiscordResponse(message, text, indicator, threadId) {
+    const content = text + (indicator ?? "");
+    const chunks = chunkMessage(content);
+    if (threadId) {
+        const threadChannel = ((client.channels.cache.get(threadId) ?? await client.channels.fetch(threadId).catch(() => null)));
+        if (threadChannel) {
+            for (let i = 0; i < chunks.length; i++) {
+                try {
+                    if (i === 0) {
+                        await message.reply(chunks[i]);
+                    }
+                    else {
+                        await threadChannel.send(chunks[i]);
+                    }
+                }
+                catch {
+                    try {
+                        await threadChannel.send(chunks[i]);
+                    }
+                    catch {
+                        // Nothing more we can do
+                    }
+                }
+            }
+            return;
+        }
+    }
+    const channel = message.channel;
+    for (let i = 0; i < chunks.length; i++) {
+        try {
+            if (i === 0) {
+                await message.reply(chunks[i]);
+            }
+            else {
+                await channel.send(chunks[i]);
+            }
+        }
+        catch {
+            try {
+                await channel.send(chunks[i]);
+            }
+            catch {
+                // Nothing more we can do
+            }
+        }
+    }
+}
+function startTypingIndicator(channel) {
+    void channel.sendTyping().catch(() => { });
+    const interval = setInterval(() => {
+        void channel.sendTyping().catch(() => { });
+    }, 8000);
+    return () => clearInterval(interval);
+}
+async function handleDiscordTurn(message, prompt, options) {
+    const effectiveChannelId = message.channel.isThread()
+        ? message.channel.parentId ?? message.channelId
+        : message.channelId;
+    const threadId = message.channel.isThread() ? message.channelId : undefined;
+    const messageId = message.id;
+    const stopTyping = startTypingIndicator(message.channel);
+    try {
+        await sendToOrchestrator(prompt, { type: "discord", channelId: effectiveChannelId, messageId, threadId }, (text, done) => {
+            if (!done) {
+                return;
+            }
+            stopTyping();
+            const routeResult = getLastRouteResult();
+            const indicator = routeResult && routeResult.routerMode === "auto"
+                ? `\n\n*⚡ auto · ${routeResult.model}*`
+                : undefined;
+            void sendDiscordResponse(message, text, indicator, threadId).catch((err) => {
+                console.error("[max] Discord response failed:", err instanceof Error ? err.message : err);
+            });
+        }, options);
+    }
+    finally {
+        stopTyping();
+    }
+}
+async function activeModelSupportsVision() {
+    try {
+        const { getClient } = await import("../copilot/client.js");
+        const sdkClient = await getClient();
+        const models = await sdkClient.listModels();
+        return models.find((model) => model.id === config.copilotModel)?.capabilities.supports.vision;
+    }
+    catch {
+        return undefined;
+    }
+}
+function sanitizeFileName(fileName) {
+    return fileName.replace(/[^a-zA-Z0-9._-]/g, "-");
+}
+async function downloadDiscordImages(imageAttachments) {
+    const tempDir = await mkdtemp(join(tmpdir(), "max-discord-"));
+    const attachments = [];
+    try {
+        for (let i = 0; i < imageAttachments.length; i++) {
+            const attachment = imageAttachments[i];
+            const urlPath = new URL(attachment.url).pathname;
+            const fallbackName = basename(urlPath) || `discord-image-${i + 1}${extname(urlPath) || ".png"}`;
+            const sourceName = attachment.name || fallbackName;
+            const safeName = sanitizeFileName(sourceName) || `discord-image-${i + 1}${extname(sourceName) || ".png"}`;
+            const filePath = join(tempDir, safeName);
+            const response = await fetch(attachment.url);
+            if (!response.ok || !response.body) {
+                throw new Error(`Discord image download failed (${response.status} ${response.statusText})`);
+            }
+            await pipeline(response.body, createWriteStream(filePath));
+            attachments.push({
+                type: "file",
+                path: filePath,
+                displayName: attachment.name || safeName,
+            });
+        }
+        return { tempDir, attachments };
+    }
+    catch (err) {
+        await removeTempDir(tempDir);
+        throw err;
+    }
+}
+async function removeTempDir(tempDir) {
+    if (!tempDir) {
+        return;
+    }
+    try {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        // Best-effort cleanup
+    }
+}
+async function handleDiscordImageMessage(message, prompt, imageAttachments) {
+    const supportsVision = await activeModelSupportsVision();
+    if (supportsVision === false) {
+        await sendDiscordResponse(message, `The current model (${config.copilotModel}) can't analyze images. Switch to a vision-capable model with /model and try again.`);
+        return;
+    }
+    let tempDir;
+    try {
+        const downloaded = await downloadDiscordImages(imageAttachments);
+        tempDir = downloaded.tempDir;
+        await handleDiscordTurn(message, prompt, { attachments: downloaded.attachments });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        await sendDiscordResponse(message, `I couldn't process that image: ${msg}`);
+    }
+    finally {
+        await removeTempDir(tempDir);
+    }
+}
+async function registerSlashCommands(readyClient) {
+    const guildIds = new Set();
+    for (const channelId of config.discordAllowedChannelIds) {
+        const resolved = readyClient.channels.cache.get(channelId)
+            ?? await readyClient.channels.fetch(channelId).catch(() => null);
+        if (resolved && "guildId" in resolved && typeof resolved.guildId === "string") {
+            guildIds.add(resolved.guildId);
+        }
+    }
+    const rest = new REST().setToken(config.discordBotToken);
+    const commandData = commands.map((command) => command.toJSON());
+    for (const guildId of guildIds) {
+        try {
+            await rest.put(Routes.applicationGuildCommands(readyClient.user.id, guildId), {
+                body: commandData,
+            });
+            console.log(`[max] Discord commands registered for guild ${guildId}`);
+        }
+        catch (err) {
+            console.error(`[max] Failed to register Discord commands for guild ${guildId}:`, err instanceof Error ? err.message : err);
+        }
+    }
+}
+async function handleSlashCommand(interaction) {
+    if (!interaction.inGuild() || !interaction.channelId || !isAllowedChannel(interaction.channelId)) {
+        try {
+            await interaction.reply({ content: "This channel isn't allowed for Max.", ephemeral: true });
+        }
+        catch {
+            // Nothing more we can do
+        }
+        return;
+    }
+    await interaction.deferReply();
+    switch (interaction.commandName) {
+        case "help": {
+            await sendDiscordInteractionResponse(interaction, getHelpText());
+            return;
+        }
+        case "cancel": {
+            const cancelled = await cancelCurrentMessage();
+            await sendDiscordInteractionResponse(interaction, cancelled ? "⛔ Cancelled." : "Nothing to cancel.");
+            return;
+        }
+        case "model": {
+            const arg = interaction.options.getString("name")?.trim();
+            if (arg) {
+                try {
+                    const { getClient } = await import("../copilot/client.js");
+                    const sdkClient = await getClient();
+                    const models = await sdkClient.listModels();
+                    const match = models.find((model) => model.id === arg);
+                    if (!match) {
+                        const suggestions = models
+                            .filter((model) => model.id.includes(arg) || model.id.toLowerCase().includes(arg.toLowerCase()))
+                            .map((model) => model.id);
+                        const hint = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : "";
+                        await sendDiscordInteractionResponse(interaction, `Model '${arg}' not found.${hint}`);
+                        return;
+                    }
+                }
+                catch {
+                    // If validation fails, allow the switch and let the next request surface any real issue.
+                }
+                const previous = config.copilotModel;
+                config.copilotModel = arg;
+                persistModel(arg);
+                invalidateSession();
+                await sendDiscordInteractionResponse(interaction, `Model: ${previous} → ${arg}`);
+                return;
+            }
+            await sendDiscordInteractionResponse(interaction, `Current model: ${config.copilotModel}`);
+            return;
+        }
+        case "auto": {
+            const current = getRouterConfig();
+            const newState = !current.enabled;
+            updateRouterConfig({ enabled: newState });
+            const label = newState
+                ? "⚡ Auto mode on"
+                : `Auto mode off · using ${config.copilotModel}`;
+            await sendDiscordInteractionResponse(interaction, label);
+            return;
+        }
+        case "memory": {
+            const memories = searchMemories(undefined, undefined, 50);
+            const text = memories.length === 0
+                ? "No memories stored."
+                : `${memories.map((memory) => `#${memory.id} [${memory.category}] ${memory.content}`).join("\n")}\n\n${memories.length} total`;
+            await sendDiscordInteractionResponse(interaction, text);
+            return;
+        }
+        case "skills": {
+            const skills = listSkills();
+            const text = skills.length === 0
+                ? "No skills installed."
+                : skills.map((skill) => `• ${skill.name} (${skill.source}) — ${skill.description}`).join("\n");
+            await sendDiscordInteractionResponse(interaction, text);
+            return;
+        }
+        case "workers": {
+            const workers = Array.from(getWorkers().values());
+            const text = workers.length === 0
+                ? "No active worker sessions."
+                : workers.map((worker) => `• ${worker.name} (${worker.workingDir}) — ${worker.status}`).join("\n");
+            await sendDiscordInteractionResponse(interaction, text);
+            return;
+        }
+        case "restart": {
+            await sendDiscordInteractionResponse(interaction, "⏳ Restarting Max...");
+            setTimeout(() => {
+                restartDaemon().catch((err) => {
+                    console.error("[max] Restart failed:", err);
+                });
+            }, 500);
+            return;
+        }
+        default: {
+            await sendDiscordInteractionResponse(interaction, "Unknown command.");
+        }
+    }
+}
+export function createDiscordBot() {
+    if (!config.discordBotToken) {
+        throw new Error("Discord bot token is missing. Run 'max setup' and enter your Discord bot token.");
+    }
+    if (config.discordAllowedChannelIds.length === 0) {
+        throw new Error("Discord allowed channel IDs are missing. Run 'max setup' and configure at least one Discord channel ID.");
+    }
+    if (client) {
+        return client;
+    }
+    client = new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+        ],
+    });
+    client.on(Events.MessageCreate, async (message) => {
+        if (message.author.bot) {
+            return;
+        }
+        const effectiveChannelId = message.channel.isThread()
+            ? message.channel.parentId ?? message.channelId
+            : message.channelId;
+        if (!isAllowedChannel(effectiveChannelId)) {
+            return;
+        }
+        try {
+            const imageAttachments = [...message.attachments.values()]
+                .filter((attachment) => attachment.contentType?.startsWith("image/"))
+                .map((attachment) => ({
+                url: attachment.url,
+                name: attachment.name,
+                contentType: attachment.contentType ?? undefined,
+            }));
+            if (imageAttachments.length > 0) {
+                const prompt = message.content.trim() || "Please analyze the attached image.";
+                await handleDiscordImageMessage(message, prompt, imageAttachments);
+                return;
+            }
+            const prompt = message.content.trim();
+            if (!prompt) {
+                return;
+            }
+            await handleDiscordTurn(message, prompt);
+        }
+        catch (err) {
+            console.error("[max] Discord message handling failed:", err instanceof Error ? err.message : err);
+            try {
+                await message.reply("Something went wrong processing that message. Please try again.");
+            }
+            catch {
+                // Nothing more we can do
+            }
+        }
+    });
+    client.on(Events.Error, (err) => {
+        console.error("[max] Discord client error (kept alive):", err.message);
+    });
+    client.on(Events.Warn, (warning) => {
+        console.warn("[max] Discord warning:", warning);
+    });
+    client.on(Events.InteractionCreate, async (interaction) => {
+        if (!interaction.isChatInputCommand()) {
+            return;
+        }
+        try {
+            await handleSlashCommand(interaction);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error("[max] Discord command failed:", msg);
+            try {
+                if (interaction.deferred || interaction.replied) {
+                    await interaction.editReply(`Error: ${msg}`);
+                }
+                else {
+                    await interaction.reply({ content: `Error: ${msg}`, ephemeral: true });
+                }
+            }
+            catch {
+                // Nothing more we can do
+            }
+        }
+    });
+    return client;
+}
+export async function startDiscordBot() {
+    if (!client) {
+        throw new Error("Discord bot not created");
+    }
+    if (!config.discordBotToken) {
+        throw new Error("Discord bot token is missing. Run 'max setup' and enter your Discord bot token.");
+    }
+    console.log("[max] Discord bot starting...");
+    try {
+        // Wait for the ClientReady event before proceeding
+        const readyPromise = new Promise((resolve) => {
+            client.once(Events.ClientReady, resolve);
+        });
+        await client.login(config.discordBotToken);
+        const readyClient = await readyPromise;
+        console.log(`[max] Discord bot connected as ${readyClient.user.tag}`);
+        await registerSlashCommands(readyClient);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error("[max] ❌ Discord bot failed to start:", msg);
+        throw err;
+    }
+}
+export async function stopDiscordBot() {
+    if (client) {
+        client.destroy();
+    }
+}
+export async function sendDiscordProactiveMessage(text, channelId, threadId) {
+    if (!client || !channelId) {
+        return;
+    }
+    if (!isAllowedChannel(channelId)) {
+        return;
+    }
+    const targetChannelId = threadId ?? channelId;
+    try {
+        const channel = client.channels.cache.get(targetChannelId) ?? await client.channels.fetch(targetChannelId).catch(() => null);
+        if (channel?.isTextBased() && "send" in channel) {
+            const chunks = chunkMessage(text);
+            for (const chunk of chunks) {
+                await channel.send(chunk);
+            }
+        }
+    }
+    catch (err) {
+        console.error("[max] Failed to send Discord proactive message:", err instanceof Error ? err.message : err);
+    }
+}
+export async function sendDiscordPhoto(photo, channelId, caption) {
+    if (!client || !channelId) {
+        return;
+    }
+    if (!isAllowedChannel(channelId)) {
+        return;
+    }
+    try {
+        const channel = await client.channels.fetch(channelId);
+        if (channel?.isTextBased() && "send" in channel) {
+            const { AttachmentBuilder } = await import("discord.js");
+            const attachment = new AttachmentBuilder(photo);
+            await channel.send({ content: caption, files: [attachment] });
+        }
+    }
+    catch (err) {
+        console.error("[max] Failed to send Discord photo:", err instanceof Error ? err.message : err);
+    }
+}
+export async function startDiscordThread(channelId, messageId, name = "Max") {
+    if (!client) {
+        throw new Error("Discord client not initialized");
+    }
+    const channel = client.channels.cache.get(channelId) ?? await client.channels.fetch(channelId);
+    if (!channel || !("messages" in channel)) {
+        throw new Error(`Channel ${channelId} not found or does not support messages`);
+    }
+    const msg = await channel.messages.fetch(messageId);
+    const thread = await msg.startThread({ name, autoArchiveDuration: ThreadAutoArchiveDuration.OneHour });
+    return thread.id;
+}
+//# sourceMappingURL=bot.js.map

package/dist/discord/formatter.js

@@ -0,0 +1,29 @@
+const DISCORD_MAX_LENGTH = 2000;
+/**
+ * Split a long message into chunks that fit within Discord's message limit.
+ * Tries to split at newlines, then spaces, falling back to hard cuts.
+ */
+export function chunkMessage(text) {
+    if (text.length <= DISCORD_MAX_LENGTH) {
+        return [text];
+    }
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= DISCORD_MAX_LENGTH) {
+            chunks.push(remaining);
+            break;
+        }
+        let splitAt = remaining.lastIndexOf("\n", DISCORD_MAX_LENGTH);
+        if (splitAt < DISCORD_MAX_LENGTH * 0.3) {
+            splitAt = remaining.lastIndexOf(" ", DISCORD_MAX_LENGTH);
+        }
+        if (splitAt < DISCORD_MAX_LENGTH * 0.3) {
+            splitAt = DISCORD_MAX_LENGTH;
+        }
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).trimStart();
+    }
+    return chunks;
+}
+//# sourceMappingURL=formatter.js.map

package/dist/paths.js

@@ -0,0 +1,37 @@
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync } from "fs";
+const profile = process.env.MAX_PROFILE?.trim() || undefined;
+const folderName = profile ? `.max-${profile}` : ".max";
+/** The active profile name, or undefined for the default (main) instance. */
+export const MAX_PROFILE = profile;
+/** True when running as the watchdog profile. */
+export const IS_WATCHDOG = profile === "watchdog";
+/** Base directory for all Max user data: ~/.max (or ~/.max-<profile>) */
+export const MAX_HOME = process.env.MAX_HOME ?? join(homedir(), folderName);
+/** Main Max's home directory — used by watchdog to read main's logs/state. */
+export const MAIN_MAX_HOME = process.env.MAIN_MAX_HOME ?? join(homedir(), ".max");
+/** Path to the SQLite database */
+export const DB_PATH = join(MAX_HOME, "max.db");
+/** Path to the user .env file */
+export const ENV_PATH = join(MAX_HOME, ".env");
+/** Path to user-local skills */
+export const SKILLS_DIR = join(MAX_HOME, "skills");
+/** Path to Max's isolated session state (keeps CLI history clean) */
+export const SESSIONS_DIR = join(MAX_HOME, "sessions");
+/** Path to TUI readline history */
+export const HISTORY_PATH = join(MAX_HOME, "tui_history");
+/** Path to optional TUI debug log */
+export const TUI_DEBUG_LOG_PATH = join(MAX_HOME, "tui-debug.log");
+/** Path to the daemon log file */
+export const DAEMON_LOG_PATH = join(MAX_HOME, "daemon.log");
+/** Path to the API bearer token file */
+export const API_TOKEN_PATH = join(MAX_HOME, "api-token");
+/** Path to user workspace instructions (~/.max/instructions/) */
+export const INSTRUCTIONS_DIR = join(MAX_HOME, "instructions");
+/** Ensure ~/.max/ and its subdirectories exist */
+export function ensureMaxHome() {
+    mkdirSync(MAX_HOME, { recursive: true });
+    mkdirSync(INSTRUCTIONS_DIR, { recursive: true });
+}
+//# sourceMappingURL=paths.js.map