heyio 1.12.1 → 3.0.0

package/dist/copilot/agents.js

@@ -1,309 +0,0 @@
-import { approveAll } from "@github/copilot-sdk";
-import { getClient } from "./client.js";
-import { getLeadForSquad, getAgentsForSquad, updateAgentStatus, getSquad } from "../store/squads.js";
-import { createTask, updateTaskStatus, getTask } from "../store/tasks.js";
-import { touchInstanceActivity, getInstance } from "../store/instances.js";
-import { selectModel, classifyComplexity } from "./model-router.js";
-import { postFeedItem } from "../store/feed.js";
-import { attachTokenTracker } from "./token-tracker.js";
-import { addAuditEntry } from "../store/audit-log.js";
-import { addAgentEvent } from "../store/agent-events.js";
-import { PATHS } from "../paths.js";
-import { createSquadTools, createLeadDelegationTools } from "./squad-tools.js";
-import { loadSkillDirectories } from "./skills.js";
-import { getMcpServersForSession } from "../mcp/registry.js";
-import { buildAttachmentPathSummary, saveAttachmentsToDisk, toCopilotBlobAttachments } from "../chat/attachments.js";
-import { existsSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import { logWarn } from "../logging.js";
-const execAsync = promisify(exec);
-// Registry of active agent sessions keyed by task ID
-const activeSessions = new Map();
-/**
- * Resolve the working directory for a squad agent session.
- * Priority: instance worktree → cloned repo → process.cwd()
- */
-async function resolveSquadWorkingDirectory(squad, instanceId) {
-    // If an instance is specified, use its worktree path
-    if (instanceId) {
-        const instance = getInstance(instanceId);
-        if (instance?.worktree_path && existsSync(instance.worktree_path)) {
-            return instance.worktree_path;
-        }
-    }
-    // Derive from squad repo_url → ~/.io/source/{owner}/{repo}
-    if (squad.repo_url) {
-        const match = squad.repo_url.match(/[/:]([^/]+)\/([^/.]+?)(?:\.git)?$/);
-        if (match) {
-            const [, owner, repo] = match;
-            const sourceDir = join(PATHS.source, owner, repo);
-            if (existsSync(sourceDir)) {
-                return sourceDir;
-            }
-            // Attempt to clone if missing
-            const parentDir = join(PATHS.source, owner);
-            if (!existsSync(parentDir))
-                mkdirSync(parentDir, { recursive: true });
-            try {
-                await execAsync(`git clone ${squad.repo_url} ${sourceDir}`, { timeout: 120_000 });
-                return sourceDir;
-            }
-            catch (err) {
-                logWarn("Failed to clone squad repository, falling back to current working directory", { repoUrl: squad.repo_url }, err);
-            }
-        }
-    }
-    return process.cwd();
-}
-/**
- * Stop a running agent by task ID. Disconnects the session and marks the task as stopped.
- */
-export async function stopTask(taskId) {
-    const session = activeSessions.get(taskId);
-    if (!session) {
-        throw new Error(`Task is not currently running or has already completed`);
-    }
-    try {
-        await session.disconnect();
-    }
-    finally {
-        activeSessions.delete(taskId);
-    }
-    updateTaskStatus(taskId, "stopped", "Stopped by user");
-    addAgentEvent(taskId, "status", "Task stopped by user", { reason: "user_requested" });
-    // Reset agent status to idle
-    const task = getTask(taskId);
-    if (task?.agent_id) {
-        updateAgentStatus(task.agent_id, "idle");
-    }
-}
-export async function delegateTask(squadId, task, instanceId, attachments = []) {
-    const lead = getLeadForSquad(squadId);
-    if (!lead) {
-        throw new Error("Squad has no team lead. Add a lead agent first.");
-    }
-    const squad = getSquad(squadId);
-    const squadSlug = squad?.slug ?? squadId;
-    const agents = getAgentsForSquad(squadId);
-    const taskRecord = createTask(squadId, task, instanceId, lead.id);
-    // Update lead status
-    updateAgentStatus(lead.id, "working");
-    // Touch instance activity if applicable
-    if (instanceId) {
-        touchInstanceActivity(instanceId);
-    }
-    // Select model based on task complexity
-    const tier = classifyComplexity(task);
-    const model = await selectModel(tier);
-    // Audit: task delegated
-    addAuditEntry("task_delegated", `Task delegated to ${lead.character_name} (${lead.role_title})`, { task: task.slice(0, 500), model }, { squad_id: squadId, agent_id: lead.id, task_id: taskRecord.id });
-    // Create ephemeral agent session for the lead
-    const client = await getClient();
-    const agentRoster = agents
-        .map((a) => `- ${a.character_name} (${a.role_title})${a.is_lead ? " [LEAD]" : ""}${a.is_qa ? " [QA]" : ""}${a.is_test ? " [TEST]" : ""}`)
-        .join("\n");
-    // Load squad wiki pages as immutable knowledge context
-    const { listPages, readPage } = await import("../wiki/fs.js");
-    const wikiPrefix = `squads/${squadSlug}`;
-    let wikiKnowledge = "";
-    try {
-        const pages = await listPages(wikiPrefix);
-        const pageContents = [];
-        for (const page of pages.slice(0, 20)) { // Cap at 20 pages to avoid token overload
-            try {
-                const content = await readPage(`${wikiPrefix}/${page}`);
-                pageContents.push(`### ${page}\n${content}`);
-            }
-            catch {
-                // Skip unreadable pages
-            }
-        }
-        if (pageContents.length > 0) {
-            wikiKnowledge = `\n## ⚠️ MANDATORY SQUAD RULES & KNOWLEDGE (from squad wiki)\n\nThese rules were written by the project owner specifically for this squad. You MUST follow them in ALL work — every task, every PR, every decision. Violating them is a critical failure.\n\nBefore starting any task, re-read these rules. Before submitting any PR or review, verify compliance.\n\n${pageContents.join("\n\n---\n\n")}\n`;
-        }
-    }
-    catch {
-        // Wiki not available — proceed without
-    }
-    const systemMessage = `# Squad Team Lead: ${lead.character_name}
-
-## 🚨 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, 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."
-
-## Identity & Role
-
-You are ${lead.character_name}, the team lead for this squad. Your PRIMARY role is coordination and delegation — you break down tasks and route implementation work to specialists via the \`delegate_to_specialist\` or \`delegate_to_specialists_parallel\` tools.
-
-## How Delegation Works
-
-When you call \`delegate_to_specialist\`, a **real, independent AI agent session** is spawned for that specialist. They have:
-- Their own full Copilot session with shell access, tools, and MCP servers
-- The squad wiki rules (immutable — they MUST follow them too)
-- Complete autonomy to implement their assigned sub-task
-
-This means specialists work IN PARALLEL with you and with each other. Use \`delegate_to_specialists_parallel\` when multiple independent sub-tasks can run concurrently.
-
-## Your Responsibilities:
-1. Break down tasks into smaller pieces and delegate to specialists
-2. Route work to the appropriate specialist based on their role
-3. Use \`delegate_to_specialists_parallel\` for independent sub-tasks (faster!)
-4. Orchestrate the full review/merge process as defined in your squad wiki
-5. Ensure quality gates are met before merging
-6. Report progress and blockers via feed_post
-
-## IMPORTANT — Prefer Delegation:
-- For implementation work (writing code, running tests, creating PRs), ALWAYS delegate to the appropriate specialist
-- For code review, delegate to squad members so they can independently review and post their own comments
-- You may perform coordination tasks directly: reading issues, checking CI status, promoting PRs, merging PRs
-- If no suitable specialist exists for a sub-task, report that back — do NOT attempt implementation yourself
-
-## Your Team:
-${agentRoster}
-
-## 🔒 SQUAD WIKI = YOUR SOURCE OF TRUTH
-
-Your squad wiki contains your **authoritative workflow rules** — branching conventions, PR process, review requirements, merge criteria, labeling, and any squad-specific constraints.
-
-**Before starting ANY task:**
-1. Read your squad wiki (use \`wiki_read\` or \`wiki_list\` to find relevant pages)
-2. Follow those rules EXACTLY — they are non-negotiable instructions from the project owner
-3. Do NOT invent your own workflow or skip steps defined in the wiki
-
-**If the wiki says all members must review → delegate reviews to all members.**
-**If the wiki says only veto members must approve → ensure veto members approve.**
-**If the wiki defines merge criteria → follow them precisely.**
-
-Failure to follow squad wiki rules is a CRITICAL FAILURE.
-
-## General Rules:
-- Always use the gh CLI for GitHub interactions
-- Use \`--comment\` for review approvals (not \`--approve\` — GitHub blocks self-approval)
-- When work is complete, ALWAYS notify the user via feed_post with a summary
-${wikiKnowledge}
-${lead.persona ? `## Personality:\n${lead.persona}` : ""}
-`;
-    let result;
-    try {
-        // Load squad-scoped tools, skills, and MCP servers
-        const squadTools = createSquadTools(squadSlug, squadId, squad?.repo_url);
-        const skillDirs = await loadSkillDirectories();
-        const mcpServers = getMcpServersForSession();
-        // Resolve correct working directory for the squad's project
-        const workDir = await resolveSquadWorkingDirectory(squad, instanceId);
-        // Create lead-specific delegation tools (allows spawning real specialist sessions)
-        const leadTools = createLeadDelegationTools(squadId, squadSlug, squad, wikiKnowledge, workDir, taskRecord.id, instanceId);
-        const session = await client.createSession({
-            model,
-            streaming: true,
-            workingDirectory: workDir,
-            systemMessage: { content: systemMessage },
-            tools: [...squadTools, ...leadTools],
-            skillDirectories: skillDirs,
-            mcpServers,
-            onPermissionRequest: approveAll,
-            infiniteSessions: {
-                enabled: true,
-                backgroundCompactionThreshold: 0.8,
-                bufferExhaustionThreshold: 0.95,
-            },
-        });
-        // Register session so it can be stopped externally
-        activeSessions.set(taskRecord.id, session);
-        const flushTokens = attachTokenTracker(session, {
-            squadId,
-            agentId: lead.id,
-            taskId: taskRecord.id,
-        });
-        try {
-            // Mark task as in progress and record start event
-            updateTaskStatus(taskRecord.id, "in_progress");
-            addAgentEvent(taskRecord.id, "status", `Task started by ${lead.character_name}`, {
-                agent: lead.character_name,
-                role: lead.role_title,
-                task,
-                attachments: attachments.map((attachment) => ({
-                    name: attachment.name,
-                    mimeType: attachment.mimeType,
-                    size: attachment.size,
-                })),
-            });
-            // Capture streaming message deltas and broadcast via SSE
-            let accumulatedMessage = "";
-            const { broadcast } = await import("../api/server.js");
-            const unsubscribeDelta = session.on("assistant.message_delta", (event) => {
-                const delta = event.data?.deltaContent ?? "";
-                if (delta) {
-                    accumulatedMessage += delta;
-                    broadcast("agent_event", {
-                        taskId: taskRecord.id,
-                        type: "message_delta",
-                        summary: accumulatedMessage,
-                        payload: { delta, accumulated: accumulatedMessage },
-                    });
-                }
-            });
-            try {
-                // Save attachments to disk so squad agents can access them via shell_exec
-                const savedAttachments = saveAttachmentsToDisk(attachments);
-                const attachmentPathInfo = buildAttachmentPathSummary(savedAttachments);
-                const response = await session.sendAndWait({
-                    prompt: `Task delegated to you:\n\n${task}${attachmentPathInfo}`,
-                    attachments: toCopilotBlobAttachments(attachments),
-                }, 7_200_000 // 2 hours — watchdog handles stale detection
-                );
-                result = response?.data?.content ?? "Task completed (no response content).";
-                // Record the final message event if we have meaningful content
-                if (accumulatedMessage.trim()) {
-                    addAgentEvent(taskRecord.id, "message", accumulatedMessage, {
-                        agent: lead.character_name,
-                        content: accumulatedMessage,
-                    });
-                }
-            }
-            finally {
-                unsubscribeDelta();
-            }
-        }
-        finally {
-            activeSessions.delete(taskRecord.id);
-            flushTokens();
-            await session.disconnect();
-        }
-    }
-    catch (err) {
-        const errMsg = err instanceof Error ? err.message : "Unknown error";
-        addAgentEvent(taskRecord.id, "status", `Task failed: ${errMsg}`, { error: errMsg });
-        updateTaskStatus(taskRecord.id, "failed", errMsg);
-        updateAgentStatus(lead.id, "idle");
-        // Audit: task failed
-        addAuditEntry("task_failed", `Task failed: ${errMsg.slice(0, 200)}`, { error: errMsg }, { squad_id: squadId, agent_id: lead.id, task_id: taskRecord.id });
-        throw err;
-    }
-    // Update task and agent status
-    updateTaskStatus(taskRecord.id, "done", result);
-    updateAgentStatus(lead.id, "idle");
-    // Audit: task completed
-    addAuditEntry("task_completed", `Task completed by ${lead.character_name}`, { result: result.slice(0, 500) }, { squad_id: squadId, agent_id: lead.id, task_id: taskRecord.id });
-    // Record completion event
-    addAgentEvent(taskRecord.id, "status", `Task completed by ${lead.character_name}`, {
-        agent: lead.character_name,
-        result: result.slice(0, 500),
-    });
-    // Post to feed
-    const squadSource = `squad-${squadSlug}`;
-    postFeedItem(squadSource, `Task completed by ${lead.character_name}`, result.slice(0, 2000));
-    return result;
-}
-//# sourceMappingURL=agents.js.map

package/dist/copilot/ceremonies.js

@@ -1,174 +0,0 @@
-import { approveAll } from "@github/copilot-sdk";
-import { getClient } from "./client.js";
-import { getLeadForSquad, getAgentsForSquad, getSquad } from "../store/squads.js";
-import { selectModel } from "./model-router.js";
-import { postFeedItem } from "../store/feed.js";
-import { attachTokenTracker } from "./token-tracker.js";
-import { buildAttachmentSummary, toCopilotBlobAttachments } from "../chat/attachments.js";
-function buildFacilitatorPrompt(lead, agents, task) {
-    const roster = agents
-        .filter((a) => !a.is_lead)
-        .map((a) => `- ${a.character_name} (${a.role_title})${a.is_qa ? " [QA]" : ""}${a.is_test ? " [TEST]" : ""}`)
-        .join("\n");
-    return `# Planning Meeting Facilitator: ${lead.character_name}
-
-You are facilitating a planning meeting for your squad. Your job is to gather input from specialists, then synthesize a clear action plan.
-
-## The Task
-${task}
-
-## Your Team (Specialists)
-${roster}
-
-## Instructions
-For each specialist who is relevant to this task, think about what their domain expertise would contribute. Then synthesize ALL perspectives into a structured plan.
-
-Consider each relevant specialist's likely concerns:
-${agents
-        .filter((a) => !a.is_lead)
-        .map((a) => `- ${a.character_name} (${a.role_title}): What risks, technical suggestions, or constraints would they raise?`)
-        .join("\n")}
-
-## Output Format
-Produce a plan in this exact format:
-
-### Task Summary
-(One sentence summary of what we're building)
-
-### Plan
-(Numbered list of work items with agent assignments)
-
-### Risks & Concerns
-(Bullet list of risks identified, with mitigation strategies)
-
-### Dependencies
-(What must happen in order, what can be parallel)
-
-### Assignments
-(Clear mapping: Agent → what they own)
-
-## Rules
-- You are ONLY planning — do NOT execute any work
-- Assign work to specialists based on their role titles
-- Identify what can be done in parallel vs what has dependencies
-- Flag if any expertise is missing from the team
-${lead.persona ? `\n## Your Style:\n${lead.persona}` : ""}
-`;
-}
-function buildSpecialistPrompt(agent, task) {
-    return `# Planning Input: ${agent.character_name}
-
-You are ${agent.character_name}, a ${agent.role_title}. Your team is planning a new task and needs your expert input.
-
-## The Task
-${task}
-
-## Your Role
-Provide input ONLY from your area of expertise (${agent.role_title}). Be specific and actionable.
-
-## Respond With
-1. **Concerns/Risks**: What could go wrong in your domain?
-2. **Technical Suggestions**: How would you approach your part?
-3. **Dependencies**: What do you need from other team members before you can start?
-4. **Estimated Complexity**: Simple / Moderate / Complex for your portion
-5. **Questions**: Anything unclear that affects your work?
-
-Keep your response focused and concise — this is a planning meeting, not implementation.
-${agent.persona ? `\n## Your Style:\n${agent.persona}` : ""}
-`;
-}
-export async function planningMeeting(squadId, task, attachments = []) {
-    const lead = getLeadForSquad(squadId);
-    if (!lead) {
-        throw new Error("Squad has no team lead. Add a lead agent first.");
-    }
-    const agents = getAgentsForSquad(squadId);
-    const relevantAgents = agents.filter((a) => !a.is_lead);
-    if (relevantAgents.length === 0) {
-        throw new Error("Squad has no specialists to consult. Add agents first.");
-    }
-    const client = await getClient();
-    // Phase 1: Gather specialist input in parallel
-    const specialistInputs = await Promise.allSettled(relevantAgents.map(async (agent) => {
-        const model = await selectModel("low");
-        const session = await client.createSession({
-            model,
-            streaming: true,
-            workingDirectory: process.cwd(),
-            systemMessage: { content: buildSpecialistPrompt(agent, task) },
-            onPermissionRequest: approveAll,
-        });
-        const flushTokens = attachTokenTracker(session, { squadId, agentId: agent.id });
-        try {
-            const response = await session.sendAndWait({
-                prompt: `Please provide your planning input for this task.${buildAttachmentSummary(attachments)}`,
-                attachments: toCopilotBlobAttachments(attachments),
-            }, 7_200_000 // 2 hours — watchdog handles stale detection
-            );
-            return {
-                agent: agent.character_name,
-                role: agent.role_title,
-                input: response?.data?.content ?? "(no response)",
-            };
-        }
-        finally {
-            flushTokens();
-            await session.disconnect();
-        }
-    }));
-    // Collect successful inputs
-    const inputs = specialistInputs
-        .filter((r) => r.status === "fulfilled")
-        .map((r) => r.value);
-    const inputsSummary = inputs
-        .map((i) => `### ${i.agent} (${i.role})\n${i.input}`)
-        .join("\n\n");
-    // Phase 2: Lead synthesizes the plan
-    const facilitatorModel = await selectModel("medium");
-    const facilitatorSession = await client.createSession({
-        model: facilitatorModel,
-        streaming: true,
-        workingDirectory: process.cwd(),
-        systemMessage: { content: buildFacilitatorPrompt(lead, agents, task) },
-        onPermissionRequest: approveAll,
-    });
-    const flushFacilitatorTokens = attachTokenTracker(facilitatorSession, {
-        squadId,
-        agentId: lead.id,
-    });
-    let plan;
-    try {
-        const prompt = `Here is the input gathered from your team:\n\n${inputsSummary}\n\nNow synthesize this into a clear, structured action plan.`;
-        const response = await facilitatorSession.sendAndWait({
-            prompt,
-            attachments: toCopilotBlobAttachments(attachments),
-        }, 7_200_000 // 2 hours — watchdog handles stale detection
-        );
-        plan = response?.data?.content ?? "Planning meeting completed but no plan was produced.";
-    }
-    finally {
-        flushFacilitatorTokens();
-        await facilitatorSession.disconnect();
-    }
-    return {
-        plan,
-        participants: [lead.character_name, ...inputs.map((i) => i.agent)],
-    };
-}
-export async function squadMeeting(squadId, task, executeAfter, attachments = []) {
-    const result = await planningMeeting(squadId, task, attachments);
-    const summary = `## Planning Meeting Complete\n\n**Participants:** ${result.participants.join(", ")}\n\n${result.plan}`;
-    if (!executeAfter) {
-        // Post to feed and wait for user to trigger execution
-        const squad = getSquad(squadId);
-        const squadSource = squad ? `squad-${squad.slug}` : `squad-${squadId}`;
-        postFeedItem(squadSource, "Planning meeting complete — awaiting approval", summary);
-        return summary;
-    }
-    // Execute: delegate with the plan as additional context
-    const { delegateTask } = await import("./agents.js");
-    const enrichedTask = `${task}\n\n---\n## Approved Plan (from team meeting)\n${result.plan}`;
-    const execResult = await delegateTask(squadId, enrichedTask, undefined, attachments);
-    return `Meeting held, then executed.\n\n${summary}\n\n---\n## Execution Result\n${execResult}`;
-}
-//# sourceMappingURL=ceremonies.js.map

package/dist/copilot/gh-token.js

@@ -1,64 +0,0 @@
-import { execSync } from "node:child_process";
-import { loadConfig, resetConfigCache } from "../config.js";
-/**
- * Cached GitHub token for CLI operations.
- * Resolution order: GH_TOKEN env → GITHUB_TOKEN env → config.githubToken → `gh auth token` CLI.
- * If no token found, retries on next call (config may have been updated).
- */
-let cachedToken;
-let resolved = false;
-export function resetGhTokenCache() {
-    cachedToken = undefined;
-    resolved = false;
-}
-export function getGhToken() {
-    if (resolved && cachedToken)
-        return cachedToken;
-    // 1. Prefer explicit env vars
-    if (process.env.GH_TOKEN) {
-        cachedToken = process.env.GH_TOKEN;
-        resolved = true;
-        return cachedToken;
-    }
-    if (process.env.GITHUB_TOKEN) {
-        cachedToken = process.env.GITHUB_TOKEN;
-        resolved = true;
-        return cachedToken;
-    }
-    // 2. Check IO config file (re-read in case it was updated since last attempt)
-    try {
-        if (!cachedToken)
-            resetConfigCache();
-        const config = loadConfig();
-        if (config.githubToken) {
-            cachedToken = config.githubToken;
-            resolved = true;
-            return cachedToken;
-        }
-    }
-    catch {
-        // Config not available
-    }
-    // 3. Try extracting from gh CLI auth (only on first attempt)
-    if (!resolved) {
-        try {
-            const token = execSync("gh auth token", {
-                timeout: 5_000,
-                encoding: "utf-8",
-                stdio: ["pipe", "pipe", "pipe"],
-            }).trim();
-            if (token) {
-                cachedToken = token;
-                resolved = true;
-            }
-        }
-        catch {
-            // gh not available or not authenticated
-        }
-    }
-    // Mark resolved only if we found a token — otherwise retry next call
-    if (cachedToken)
-        resolved = true;
-    return cachedToken;
-}
-//# sourceMappingURL=gh-token.js.map

package/dist/copilot/io-scheduler.js

@@ -1,79 +0,0 @@
-import { listSchedules, updateScheduleLastRun } from "../store/schedules.js";
-import { sendToOrchestrator } from "./orchestrator.js";
-let ioSchedulerInterval;
-export function startIoScheduler() {
-    ioSchedulerInterval = setInterval(() => {
-        checkIoSchedules();
-    }, 60_000);
-    ioSchedulerInterval.unref();
-}
-function checkIoSchedules() {
-    const schedules = listSchedules("io");
-    const now = new Date();
-    for (const schedule of schedules) {
-        if (!schedule.enabled)
-            continue;
-        if (!isDue(schedule.cron, schedule.last_run, now))
-            continue;
-        if (!schedule.squad_id) {
-            console.warn(`[io-scheduler] Schedule ${schedule.id} skipped: missing squad_id.`);
-            continue;
-        }
-        updateScheduleLastRun(schedule.id);
-        sendToOrchestrator(buildSquadScopedPrompt(schedule), "io-scheduler", (_text, done) => {
-            if (done) {
-                console.log(`[io-scheduler] Schedule ${schedule.id} completed.`);
-            }
-        });
-    }
-}
-export function buildSquadScopedPrompt(schedule) {
-    const squadId = schedule.squad_id ?? "unknown";
-    return `[Squad Schedule] Run for squad ${squadId}. Prompt: ${schedule.prompt}`;
-}
-function isDue(cron, lastRun, now) {
-    const parts = cron.split(" ");
-    if (parts.length !== 5)
-        return false;
-    const [minSpec, hourSpec, daySpec, monthSpec, weekdaySpec] = parts;
-    if (!matchesCronField(minSpec, now.getMinutes()))
-        return false;
-    if (!matchesCronField(hourSpec, now.getHours()))
-        return false;
-    if (!matchesCronField(daySpec, now.getDate()))
-        return false;
-    if (!matchesCronField(monthSpec, now.getMonth() + 1))
-        return false;
-    if (!matchesCronField(weekdaySpec, now.getDay()))
-        return false;
-    if (lastRun) {
-        const lastDate = new Date(lastRun);
-        const diffMs = now.getTime() - lastDate.getTime();
-        if (diffMs < 60_000)
-            return false;
-    }
-    return true;
-}
-function matchesCronField(spec, value) {
-    if (spec === "*")
-        return true;
-    if (spec.includes("-")) {
-        const [start, end] = spec.split("-").map(Number);
-        return value >= start && value <= end;
-    }
-    if (spec.includes(",")) {
-        return spec.split(",").map(Number).includes(value);
-    }
-    if (spec.startsWith("*/")) {
-        const step = parseInt(spec.slice(2), 10);
-        return value % step === 0;
-    }
-    return parseInt(spec, 10) === value;
-}
-export function stopIoScheduler() {
-    if (ioSchedulerInterval) {
-        clearInterval(ioSchedulerInterval);
-        ioSchedulerInterval = undefined;
-    }
-}
-//# sourceMappingURL=io-scheduler.js.map