heyio 1.12.1 → 3.0.0

package/dist/copilot/squad-tools.js

@@ -1,258 +0,0 @@
-import { z } from "zod";
-import { defineTool } from "@github/copilot-sdk";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import { join } from "node:path";
-import { PATHS } from "../paths.js";
-import { getGhToken } from "./gh-token.js";
-const execAsync = promisify(exec);
-/**
- * Resolve the project root directory for a squad from its repo_url.
- * Returns the path under ~/.io/source/{owner}/{repo} or null if unknown.
- */
-function resolveSquadProjectDir(repoUrl) {
-    if (!repoUrl)
-        return null;
-    const match = repoUrl.match(/[/:]([^/]+)\/([^/.]+?)(?:\.git)?$/);
-    if (!match)
-        return null;
-    const [, owner, repo] = match;
-    return join(PATHS.source, owner, repo);
-}
-/**
- * Creates a scoped set of tools for squad agent sessions.
- * Wiki tools are sandboxed to the squad's own wiki subfolder.
- * Feed posts are locked to the squad's source identifier.
- */
-export function createSquadTools(squadSlug, squadId, repoUrl) {
-    const wikiPrefix = `squads/${squadSlug}`;
-    const projectDir = resolveSquadProjectDir(repoUrl ?? null);
-    return [
-        // --- Wiki Tools (scoped to squads/{slug}/) ---
-        defineTool("wiki_read", {
-            description: `Read a wiki page from the squad wiki (paths are relative to your squad's wiki folder — do NOT include 'squads/${squadSlug}/' prefix)`,
-            parameters: z.object({
-                path: z.string().describe("Page path (e.g., 'decisions.md', 'notes/architecture.md')"),
-            }),
-            handler: async ({ path }) => {
-                const { readPage } = await import("../wiki/fs.js");
-                // Strip redundant prefix if agent accidentally includes it
-                const cleanPath = path.replace(new RegExp(`^(?:squads/${squadSlug}/)+`), "");
-                return await readPage(`${wikiPrefix}/${cleanPath}`);
-            },
-        }),
-        defineTool("wiki_write", {
-            description: "Write or update a wiki page in the squad wiki (paths are relative — do NOT include the squad prefix)",
-            parameters: z.object({
-                path: z.string().describe("Page path (e.g., 'decisions.md')"),
-                content: z.string().describe("Markdown content to write"),
-            }),
-            handler: async ({ path, content }) => {
-                const { writePage } = await import("../wiki/fs.js");
-                // Strip redundant prefix if agent accidentally includes it
-                const cleanPath = path.replace(new RegExp(`^(?:squads/${squadSlug}/)+`), "");
-                await writePage(`${wikiPrefix}/${cleanPath}`, content);
-                return `Page saved: ${cleanPath}`;
-            },
-        }),
-        defineTool("wiki_list", {
-            description: "List all wiki pages in the squad wiki",
-            parameters: z.object({}),
-            handler: async () => {
-                const { listPages } = await import("../wiki/fs.js");
-                return await listPages(wikiPrefix);
-            },
-        }),
-        defineTool("wiki_search", {
-            description: "Search squad wiki pages by keyword",
-            parameters: z.object({
-                query: z.string().describe("Search query"),
-            }),
-            handler: async ({ query }) => {
-                const { searchSquadPages } = await import("../wiki/search.js");
-                return await searchSquadPages(query, wikiPrefix);
-            },
-        }),
-        defineTool("wiki_delete", {
-            description: "Delete a wiki page from the squad wiki",
-            parameters: z.object({
-                path: z.string().describe("Page path to delete"),
-            }),
-            handler: async ({ path }) => {
-                const { deletePage } = await import("../wiki/fs.js");
-                const cleanPath = path.replace(new RegExp(`^(?:squads/${squadSlug}/)+`), "");
-                await deletePage(`${wikiPrefix}/${cleanPath}`);
-                return `Page deleted: ${cleanPath}`;
-            },
-        }),
-        defineTool("wiki_backlinks", {
-            description: "Find all squad wiki pages that link to the given page",
-            parameters: z.object({
-                path: z.string().describe("Page path (e.g., 'decisions.md')"),
-            }),
-            handler: async ({ path }) => {
-                const { getBacklinks } = await import("../wiki/backlinks.js");
-                const cleanPath = path.replace(new RegExp(`^(?:squads/${squadSlug}/)+`), "");
-                const allBacklinks = await getBacklinks(`${wikiPrefix}/${cleanPath}`);
-                // Filter to only show backlinks within squad wiki, strip prefix for display
-                return allBacklinks
-                    .filter((bl) => bl.startsWith(`${wikiPrefix}/`))
-                    .map((bl) => bl.slice(wikiPrefix.length + 1));
-            },
-        }),
-        // --- Feed Tools ---
-        defineTool("feed_post", {
-            description: "Post a message or deliverable to the user's inbox. Use for progress updates, questions, blockers, or completed work.",
-            parameters: z.object({
-                title: z.string().describe("Title of the message"),
-                content: z.string().describe("Full content (markdown supported)"),
-            }),
-            handler: async ({ title, content }) => {
-                const { postFeedItem } = await import("../store/feed.js");
-                const source = `squad-${squadSlug}`;
-                const item = postFeedItem(source, title, content);
-                return `Posted to inbox: "${title}" (ID: ${item.id})`;
-            },
-        }),
-        // --- Task Tools ---
-        defineTool("squad_task_status", {
-            description: "Check the status of tasks for your squad",
-            parameters: z.object({}),
-            handler: async () => {
-                const { getTasksForSquad } = await import("../store/tasks.js");
-                return getTasksForSquad(squadId);
-            },
-        }),
-        // --- Shell Tool (scoped to project directory) ---
-        defineTool("shell_exec", {
-            description: "Execute a shell command in the squad's project directory. Use for git, build tools, test runners, file operations, etc.",
-            parameters: z.object({
-                command: z.string().describe("Shell command to execute"),
-                cwd: z
-                    .string()
-                    .optional()
-                    .describe("Working directory relative to project root (optional, defaults to project root)"),
-            }),
-            handler: async ({ command, cwd }) => {
-                const baseDir = projectDir ?? process.cwd();
-                // If cwd is provided, resolve it relative to the project dir
-                const workDir = cwd ? join(baseDir, cwd) : baseDir;
-                // Safety: ensure workDir is under baseDir
-                const resolved = join(workDir);
-                if (!resolved.startsWith(baseDir)) {
-                    return `Error: cannot execute commands outside the project directory`;
-                }
-                try {
-                    // Inject cached GH token for GitHub CLI operations
-                    const shellEnv = { ...process.env, GH_PROMPT_DISABLED: "1" };
-                    const ghToken = getGhToken();
-                    if (ghToken) {
-                        shellEnv.GH_TOKEN = ghToken;
-                    }
-                    const { stdout } = await execAsync(command, {
-                        cwd: workDir,
-                        timeout: 120_000,
-                        maxBuffer: 2 * 1024 * 1024,
-                        env: shellEnv,
-                    });
-                    return stdout.trim() || "(no output)";
-                }
-                catch (err) {
-                    const stderr = err.stderr?.toString().trim() ?? "";
-                    const stdout = err.stdout?.toString().trim() ?? "";
-                    return `Error (exit ${err.code ?? 1}): ${stderr || stdout || err.message}`;
-                }
-            },
-        }),
-    ];
-}
-/**
- * Additional tools available ONLY to team leads.
- * Includes the delegate_to_specialist tool which spawns real parallel agent sessions.
- */
-export function createLeadDelegationTools(squadId, squadSlug, squad, wikiKnowledge, workDir, parentTaskId, instanceId) {
-    return [
-        defineTool("delegate_to_specialist", {
-            description: "Delegate a sub-task to a specialist agent. This spawns an INDEPENDENT session for that agent — they will execute the work in parallel. Use this to assign implementation work to the right specialist based on their role. You can call this multiple times to delegate to multiple specialists in parallel.",
-            parameters: z.object({
-                agent_name: z.string().describe("Character name of the specialist to delegate to (from your team roster)"),
-                sub_task: z.string().describe("Detailed description of the sub-task. Be specific about what to implement, which files to touch, acceptance criteria, and branch to work on."),
-            }),
-            handler: async ({ agent_name, sub_task }) => {
-                const { getAgentsForSquad } = await import("../store/squads.js");
-                const agents = getAgentsForSquad(squadId);
-                const agent = agents.find((a) => a.character_name.toLowerCase() === agent_name.toLowerCase() && !a.is_lead);
-                if (!agent) {
-                    const available = agents
-                        .filter((a) => !a.is_lead)
-                        .map((a) => `${a.character_name} (${a.role_title})`)
-                        .join(", ");
-                    return `Error: No specialist found with name "${agent_name}". Available specialists: ${available}`;
-                }
-                const { runSpecialistSession } = await import("./specialist-runner.js");
-                const result = await runSpecialistSession({
-                    agent,
-                    squad,
-                    squadSlug,
-                    squadId,
-                    task: sub_task,
-                    wikiKnowledge,
-                    workDir,
-                    instanceId,
-                    parentTaskId,
-                });
-                if (result.success) {
-                    return `✅ ${result.agentName} (${result.role}) completed the task:\n\n${result.result}`;
-                }
-                else {
-                    return `❌ ${result.agentName} (${result.role}) failed:\n\n${result.result}`;
-                }
-            },
-        }),
-        defineTool("delegate_to_specialists_parallel", {
-            description: "Delegate multiple sub-tasks to different specialists IN PARALLEL. All tasks run concurrently and results are returned together. Use this when multiple independent sub-tasks can be worked on simultaneously by different specialists.",
-            parameters: z.object({
-                assignments: z.array(z.object({
-                    agent_name: z.string().describe("Character name of the specialist"),
-                    sub_task: z.string().describe("Detailed sub-task description"),
-                })).describe("Array of agent assignments to execute in parallel"),
-            }),
-            handler: async ({ assignments }) => {
-                const { getAgentsForSquad } = await import("../store/squads.js");
-                const { runSpecialistsParallel } = await import("./specialist-runner.js");
-                const agents = getAgentsForSquad(squadId);
-                const requests = [];
-                const errors = [];
-                for (const assignment of assignments) {
-                    const agent = agents.find((a) => a.character_name.toLowerCase() === assignment.agent_name.toLowerCase() && !a.is_lead);
-                    if (!agent) {
-                        errors.push(`No specialist found: "${assignment.agent_name}"`);
-                        continue;
-                    }
-                    requests.push({
-                        agent,
-                        squad,
-                        squadSlug,
-                        squadId,
-                        task: assignment.sub_task,
-                        wikiKnowledge,
-                        workDir,
-                        instanceId,
-                        parentTaskId,
-                    });
-                }
-                if (requests.length === 0) {
-                    return `Error: No valid specialists matched. ${errors.join("; ")}`;
-                }
-                const results = await runSpecialistsParallel(requests);
-                const summaries = results.map((r) => {
-                    const status = r.success ? "✅" : "❌";
-                    return `${status} **${r.agentName}** (${r.role}):\n${r.result}`;
-                });
-                const preamble = errors.length > 0 ? `⚠️ Skipped: ${errors.join("; ")}\n\n` : "";
-                return `${preamble}## Parallel Results\n\n${summaries.join("\n\n---\n\n")}`;
-            },
-        }),
-    ];
-}
-//# sourceMappingURL=squad-tools.js.map

package/dist/copilot/system-message.js

@@ -1,86 +0,0 @@
-import { PATHS } from "../paths.js";
-export function buildSystemMessage(selfEditEnabled) {
-    const selfEditBlock = selfEditEnabled
-        ? ""
-        : `
-## Self-Edit Protection
-You must NEVER modify files within your own installation directory. If asked to modify your own source code, decline and suggest the user restart with --self-edit. This restriction does NOT apply to: user project files, skills in ~/.io/skills/, ~/.io/config.json, wiki pages, or files outside the IO installation directory.
-`;
-    return `# IO — Personal AI Assistant
-
-You are IO, a personal AI assistant daemon. You run 24/7 on the user's machine, helping them manage projects through AI-powered squads, answer questions, and automate workflows.
-
-## Core Capabilities
-- Manage project squads (teams of AI agents themed after pop culture universes)
-- Read and write to a persistent wiki knowledge base at ~/.io/wiki/
-- Each squad has its own wiki at ~/.io/wiki/pages/squads/{squad-slug}/ (use the slug, never the UUID)
-- Squad wiki templates at ~/.io/wiki/templates/squad/ are auto-copied to new squads on creation
-- Delegate complex tasks to squad team leads
-- Track deliverables in a unified feed
-- Schedule recurring tasks and stand-ups
-- Connect to external tools via MCP servers
-
-## 🚨 CRITICAL SECURITY RULE — ABSOLUTE, NON-NEGOTIABLE 🚨
-You must NEVER expose secrets, credentials, or sensitive values in ANY publicly visible location. This includes:
-- GitHub issues, pull requests, PR descriptions, comments, or commit messages
-- Log output, error messages, or stack traces shared externally
-- Wiki pages, feed items, or any content viewable by others
-
-What counts as a secret: API keys, access tokens, passwords, connection strings, environment variable values, private config file contents (supabaseAnonKey, telegramToken, etc.), SSH keys, certificates, webhook URLs with tokens.
-
-If you need to reference that a secret exists, use \`<REDACTED>\` or \`***\` as a placeholder. NEVER include the actual value.
-
-Violation of this rule is a HARD FAILURE — no exceptions, no workarounds, no "just this once."
-
-## Behavioral Rules
-- Always pull latest before starting any code work (git fetch origin && git checkout main && git pull origin main)
-- Always delegate code work to the relevant squad — never implement directly
-- Always delegate to the team lead, never to a specific agent (unless explicitly named by the user)
-- Never delegate unless explicitly asked — creating an issue ≠ request to start work
-- When delegating, ALWAYS instruct the squad to notify the user via the inbox (feed_post) when work is complete
-- When creating squads, research the universe dynamically — never use hardcoded character lists
-- **Always use the gh CLI** for all GitHub interactions (repos, issues, PRs, releases, actions, etc.). Only fall back to the GitHub API or other methods if gh is unavailable or cannot accomplish the task.
-- For complex tasks involving multiple specialists, use squad_meeting to have the team plan together before executing. Use squad_delegate for straightforward single-domain tasks.
-- If the user says "plan this" or "have the team meet" → use squad_meeting with execute_after=false
-- If the user says "do this" for a complex task → use squad_meeting with execute_after=true
-- If the user says "just do it" or it's a simple task → use squad_delegate directly
-
-## HARD RULE: Squad Ownership Boundary
-If a project has a squad assigned to it, you (the orchestrator) must NEVER:
-- Research, analyze, or investigate the project's code, issues, or state yourself
-- Attempt any work — even preliminary analysis — before delegating
-- "Look into" or "check on" something before passing it to the squad
-- Wait for the squad to finish before responding to the user
-
-When a request comes in about a squad-owned project, you IMMEDIATELY delegate to that squad's team lead with no pre-processing. The squad handles ALL work including research, analysis, planning, and execution.
-
-After delegating, IMMEDIATELY confirm to the user that the task is in the squad's hands (e.g., "I've handed this off to [squad name]. They'll work on it and post updates to your inbox."). Do NOT block or wait for the squad to complete — they work asynchronously in the background.
-
-The ONLY thing you are allowed to do regarding a squad-owned project (without delegating) is:
-- Answer questions about what the squad has already done (using feed/task history)
-- Report squad status, task progress, or past deliverables
-
-## Squad Coverage Requirements
-Every squad MUST have:
-1. A dedicated team lead (PM/Senior Engineer, coordination-only — **never writes code**)
-2. At least one QA reviewer
-3. At least one agent with a test/quality role title
-
-Team leads are strictly managers/delegators/reviewers. They break down tasks, assign work to specialists, coordinate reviews, and report status — but they NEVER write, edit, or generate code themselves.
-
-## GitHub Self-Review Limitation
-All squad agents share the repo owner's gh identity. GitHub blocks self-approval. Veto reviewers use --comment with "LGTM" instead of --approve. Merge criteria: all veto-capable members have posted approving comments + CI passes + no conflicts.
-${selfEditBlock}
-## Source Code Convention
-- All repositories are cloned to ~/.io/source/{owner}/{repo}
-- When creating a squad with a repo_url, the repo is automatically cloned there
-- When working with a squad's code, always use ~/.io/source/{owner}/{repo} as the working directory
-
-## Environment
-- OS: ${process.platform}
-- Working directory: ${process.cwd()}
-- Wiki: ${PATHS.wiki}
-- Skills: ${PATHS.skills}
-`;
-}
-//# sourceMappingURL=system-message.js.map

package/dist/copilot/token-tracker.js

@@ -1,98 +0,0 @@
-import { loadConfig } from "../config.js";
-import { recordTokenUsage } from "../store/token-usage.js";
-import { postFeedItem } from "../store/feed.js";
-const NANO_AIU_TO_USD = 1e-14;
-/**
- * Default model pricing (USD per 1M tokens).
- * Used when modelPricing is not configured.
- */
-export const DEFAULT_MODEL_PRICING = {
-    "gpt-4.1": { inputPer1M: 2.0, outputPer1M: 8.0 },
-    "gpt-5.2": { inputPer1M: 2.5, outputPer1M: 10.0 },
-    "gpt-5.2-codex": { inputPer1M: 3.0, outputPer1M: 12.0 },
-    "gpt-5.3-codex": { inputPer1M: 3.0, outputPer1M: 12.0 },
-    "gpt-5.4": { inputPer1M: 5.0, outputPer1M: 20.0 },
-    "gpt-5.5": { inputPer1M: 7.5, outputPer1M: 30.0 },
-    "gpt-5-mini": { inputPer1M: 0.15, outputPer1M: 0.60 },
-    "gpt-5.4-mini": { inputPer1M: 0.15, outputPer1M: 0.60 },
-    "claude-haiku-4.5": { inputPer1M: 0.80, outputPer1M: 4.0 },
-    "claude-sonnet-4.5": { inputPer1M: 3.0, outputPer1M: 15.0 },
-    "claude-sonnet-4.6": { inputPer1M: 3.0, outputPer1M: 15.0 },
-    "claude-opus-4.5": { inputPer1M: 15.0, outputPer1M: 75.0 },
-    "claude-opus-4.6": { inputPer1M: 15.0, outputPer1M: 75.0 },
-    "claude-opus-4.7": { inputPer1M: 15.0, outputPer1M: 75.0 },
-};
-/**
- * Compute estimated cost in USD for the given token counts and model.
- */
-export function estimateCost(model, inputTokens, outputTokens) {
-    const config = loadConfig();
-    const pricing = config.modelPricing?.[model] ?? DEFAULT_MODEL_PRICING[model];
-    if (!pricing)
-        return 0;
-    return (inputTokens / 1_000_000) * pricing.inputPer1M + (outputTokens / 1_000_000) * pricing.outputPer1M;
-}
-function resolveCostUsd(data, model, inputTokens, outputTokens) {
-    const totalNanoAiu = data?.copilotUsage?.totalNanoAiu;
-    if (typeof totalNanoAiu === "number" && Number.isFinite(totalNanoAiu)) {
-        return totalNanoAiu * NANO_AIU_TO_USD;
-    }
-    return estimateCost(model, inputTokens, outputTokens);
-}
-/**
- * Attach a token usage listener to a CopilotSession.
- * Returns a `flush` function that, when called, persists accumulated
- * token usage to the database and returns the totals.
- *
- * Call `flush` after the session ends (in a finally block).
- */
-export function attachTokenTracker(session, context) {
-    const accumulator = {};
-    const unsubscribe = session.on("assistant.usage", (event) => {
-        const data = event?.data;
-        if (!data?.model)
-            return;
-        const model = data.model;
-        const input = data.inputTokens ?? 0;
-        const output = data.outputTokens ?? 0;
-        if (!accumulator[model])
-            accumulator[model] = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
-        accumulator[model].inputTokens += input;
-        accumulator[model].outputTokens += output;
-        accumulator[model].costUsd += resolveCostUsd(data, model, input, output);
-    });
-    return () => {
-        unsubscribe();
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        let totalCostUsd = 0;
-        for (const [model, usage] of Object.entries(accumulator)) {
-            if (usage.inputTokens === 0 && usage.outputTokens === 0)
-                continue;
-            const costUsd = usage.costUsd ?? estimateCost(model, usage.inputTokens, usage.outputTokens);
-            recordTokenUsage({
-                squadId: context.squadId,
-                agentId: context.agentId,
-                taskId: context.taskId,
-                model,
-                inputTokens: usage.inputTokens,
-                outputTokens: usage.outputTokens,
-                costUsd,
-            });
-            totalInputTokens += usage.inputTokens;
-            totalOutputTokens += usage.outputTokens;
-            totalCostUsd += costUsd;
-        }
-        // Alert on runaway agents
-        const config = loadConfig();
-        const threshold = config.tokenAlertThreshold;
-        if (threshold && (totalInputTokens + totalOutputTokens) > threshold) {
-            const source = context.squadId ? `squad-${context.squadId}` : "system";
-            postFeedItem(source, "⚠️ Token usage alert", `A task consumed ${totalInputTokens + totalOutputTokens} tokens (threshold: ${threshold}). ` +
-                `Estimated cost: $${totalCostUsd.toFixed(4)}. ` +
-                (context.taskId ? `Task ID: ${context.taskId}` : ""));
-        }
-        return { totalInputTokens, totalOutputTokens, totalCostUsd };
-    };
-}
-//# sourceMappingURL=token-tracker.js.map

package/dist/copilot/trigger-schedule.js

@@ -1,33 +0,0 @@
-import { getSchedule, updateScheduleLastRun } from "../store/schedules.js";
-import { sendToOrchestrator } from "./orchestrator.js";
-import { buildSquadScopedPrompt } from "./io-scheduler.js";
-import { delegateTask } from "./agents.js";
-/**
- * Trigger a schedule immediately, bypassing cron timing.
- * Returns the schedule if triggered successfully, or undefined if not found.
- */
-export function triggerSchedule(id) {
-    const schedule = getSchedule(id);
-    if (!schedule)
-        return undefined;
-    updateScheduleLastRun(schedule.id);
-    if (schedule.type === "squad") {
-        if (!schedule.squad_id)
-            return schedule;
-        const task = schedule.prompt || `Run "triage" stand-up. Agenda: triage`;
-        // Delegate directly to squad lead — same path as the cron scheduler
-        delegateTask(schedule.squad_id, task).catch((err) => {
-            const errMsg = err instanceof Error ? err.message : "Unknown error";
-            console.error(`[trigger] Delegation failed for squad ${schedule.squad_id}: ${errMsg}`);
-        });
-    }
-    else {
-        sendToOrchestrator(buildSquadScopedPrompt(schedule), "io-scheduler", (_text, done) => {
-            if (done) {
-                console.log(`[trigger] IO schedule ${schedule.id} completed.`);
-            }
-        });
-    }
-    return schedule;
-}
-//# sourceMappingURL=trigger-schedule.js.map

package/dist/daemon.js

@@ -1,67 +0,0 @@
-import { loadConfig, getConfigWarning } from "./config.js";
-import { getDb, closeDb } from "./store/db.js";
-import { PATHS } from "./paths.js";
-import { mkdirSync, existsSync } from "node:fs";
-export async function startDaemon(opts) {
-    console.log("[io] Starting daemon...");
-    // Ensure directories exist
-    for (const dir of [PATHS.home, PATHS.wiki, PATHS.wikiPages, PATHS.skills, PATHS.sessions]) {
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-    }
-    const config = loadConfig();
-    // Initialize database
-    const db = getDb();
-    console.log("[io] Database initialized.");
-    // Initialize Copilot client & orchestrator
-    const { getClient } = await import("./copilot/client.js");
-    const client = await getClient();
-    console.log("[io] Copilot client connected.");
-    const { initOrchestrator } = await import("./copilot/orchestrator.js");
-    await initOrchestrator(client, { selfEdit: opts.selfEdit });
-    console.log("[io] Orchestrator session ready.");
-    // Start HTTP API server
-    const { startApiServer } = await import("./api/server.js");
-    await startApiServer(config);
-    console.log(`[io] API server listening on port ${config.port}.`);
-    // Start Telegram bot (if configured)
-    if (config.telegramEnabled && config.telegramBotToken) {
-        const { startBot } = await import("./telegram/bot.js");
-        await startBot(config);
-        console.log("[io] Telegram bot started.");
-    }
-    // Start schedulers
-    const { startSquadScheduler } = await import("./copilot/scheduler.js");
-    const { startIoScheduler } = await import("./copilot/io-scheduler.js");
-    startSquadScheduler();
-    startIoScheduler();
-    console.log("[io] Schedulers active.");
-    // Start watchdog
-    if (config.watchdogEnabled) {
-        const { startWatchdog } = await import("./watchdog.js");
-        startWatchdog();
-        console.log("[io] Watchdog active.");
-    }
-    console.log("[io] Daemon running. Press Ctrl+C to stop.");
-    // Notify user if config had to fall back to defaults
-    const configWarn = getConfigWarning();
-    if (configWarn) {
-        const { postFeedItem } = await import("./store/feed.js");
-        postFeedItem("system", "⚠️ Config Warning", configWarn);
-    }
-    // Graceful shutdown
-    let shuttingDown = false;
-    const shutdown = async () => {
-        if (shuttingDown) {
-            console.log("[io] Forcing exit...");
-            process.exit(1);
-        }
-        shuttingDown = true;
-        console.log("\n[io] Shutting down...");
-        closeDb();
-        process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-}
-//# sourceMappingURL=daemon.js.map

package/dist/logging.js

@@ -1,27 +0,0 @@
-export function formatError(err) {
-    if (err instanceof Error)
-        return err.message;
-    if (typeof err === "string")
-        return err;
-    try {
-        return JSON.stringify(err);
-    }
-    catch {
-        return String(err);
-    }
-}
-export function logWarn(message, context = {}, err) {
-    const payload = {
-        ...context,
-        ...(err ? { error: formatError(err) } : {}),
-    };
-    console.warn(`[io] ${message}`, payload);
-}
-export function logError(message, context = {}, err) {
-    const payload = {
-        ...context,
-        ...(err ? { error: formatError(err) } : {}),
-    };
-    console.error(`[io] ${message}`, payload);
-}
-//# sourceMappingURL=logging.js.map

package/dist/mcp/config.js

@@ -1,29 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { PATHS } from "../paths.js";
-export function loadMcpConfig() {
-    if (!existsSync(PATHS.mcpConfig))
-        return [];
-    const raw = JSON.parse(readFileSync(PATHS.mcpConfig, "utf-8"));
-    return Array.isArray(raw.servers) ? raw.servers : [];
-}
-export function saveMcpConfig(servers) {
-    writeFileSync(PATHS.mcpConfig, JSON.stringify({ servers }, null, 2) + "\n");
-}
-export function addMcpServer(server) {
-    const servers = loadMcpConfig();
-    servers.push(server);
-    saveMcpConfig(servers);
-}
-export function removeMcpServer(id) {
-    const servers = loadMcpConfig().filter((s) => s.id !== id);
-    saveMcpConfig(servers);
-}
-export function toggleMcpServer(id, enabled) {
-    const servers = loadMcpConfig();
-    const server = servers.find((s) => s.id === id);
-    if (server) {
-        server.enabled = enabled;
-        saveMcpConfig(servers);
-    }
-}
-//# sourceMappingURL=config.js.map

package/dist/mcp/index.js

@@ -1,3 +0,0 @@
-export { loadMcpConfig, saveMcpConfig, addMcpServer, removeMcpServer, toggleMcpServer } from "./config.js";
-export { initMcpRegistry, getMcpServersForSession, listServers } from "./registry.js";
-//# sourceMappingURL=index.js.map

package/dist/mcp/registry.js

@@ -1,42 +0,0 @@
-import { loadMcpConfig } from "./config.js";
-// Module-level array of MCP tools loaded at startup
-let loadedServers = [];
-export function initMcpRegistry() {
-    loadedServers = loadMcpConfig().filter((s) => s.enabled);
-}
-export function getMcpServersForSession() {
-    if (loadedServers.length === 0)
-        return undefined;
-    const result = {};
-    for (const server of loadedServers) {
-        if (server.type === "stdio" && server.command) {
-            result[server.name] = {
-                type: "local",
-                command: server.command,
-                args: server.args ?? [],
-                env: server.env,
-                tools: ["*"],
-            };
-        }
-        else if (server.type === "http" && server.url) {
-            result[server.name] = {
-                type: "http",
-                url: server.url,
-                headers: server.headers,
-            };
-        }
-    }
-    return Object.keys(result).length > 0 ? result : undefined;
-}
-export function listServers() {
-    return loadMcpConfig();
-}
-export function addServerToRegistry(server) {
-    if (server.enabled) {
-        loadedServers.push(server);
-    }
-}
-export function removeServerFromRegistry(id) {
-    loadedServers = loadedServers.filter((s) => s.id !== id);
-}
-//# sourceMappingURL=registry.js.map