@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/skills/skillsManager.js

@@ -1,281 +0,0 @@
-/**
- * SkillsManager — orchestrates the skill store, cached index, index-first
- * search (hydrating instructions only for matches), prompt-index rendering,
- * and the mutation gate.
- *
- * Read paths fail open (errors surface as empty results + a warn log);
- * write paths fail closed (errors reject the mutation).
- */
-import { randomUUID } from "node:crypto";
-import { logger } from "../utils/logger.js";
-import { filterSkillIndex, formatSkillsPromptIndex, renderSkillListing, sortSkillIndex, } from "./skillMatcher.js";
-import { SkillSessionTracker } from "./skillSessionTracker.js";
-import { createSkillStore } from "./skillStores.js";
-const DEFAULT_MAX_MATCHES = 5;
-const DEFAULT_PROMPT_INDEX_MAX_ITEMS = 50;
-const DEFAULT_INDEX_CACHE_TTL_MS = 30_000;
-const DEFAULT_LISTING_BUDGET_CHARS = 15_000;
-export class SkillsManager {
-    config;
-    store;
-    cachedIndex = null;
-    cachedIndexAt = 0;
-    /** Serializes writes within this process — see requestMutation(). */
-    mutationQueue = Promise.resolve();
-    /** Per-session activation state (pinned skills). */
-    sessions = new SkillSessionTracker();
-    constructor(config) {
-        this.config = config;
-        this.store = createSkillStore(config.storage);
-    }
-    /**
-     * Cached index read, sorted by name. TTL 0 disables caching. Sorting
-     * here (not per render) keeps every downstream listing byte-stable
-     * regardless of store enumeration order.
-     */
-    async getIndex(forceRefresh = false) {
-        const ttl = this.config.indexCacheTtlMs ?? DEFAULT_INDEX_CACHE_TTL_MS;
-        const fresh = this.cachedIndex !== null &&
-            ttl > 0 &&
-            Date.now() - this.cachedIndexAt < ttl;
-        if (fresh && !forceRefresh && this.cachedIndex) {
-            return this.cachedIndex;
-        }
-        const index = sortSkillIndex(await this.store.index());
-        this.cachedIndex = index;
-        this.cachedIndexAt = Date.now();
-        return index;
-    }
-    invalidateIndex() {
-        this.cachedIndex = null;
-        this.store.invalidate?.();
-    }
-    /**
-     * Index-first search: filter the cached index, hydrate only the matched
-     * entries (max `limit`) with instructions. Cost: one cached index read +
-     * N_matched store gets.
-     */
-    async search(query) {
-        const limit = query.limit ?? this.config.maxMatches ?? DEFAULT_MAX_MATCHES;
-        const scopeId = query.scopeId ?? this.config.defaultScopeId;
-        const index = await this.getIndex();
-        const matched = filterSkillIndex(index, {
-            ...query,
-            ...(scopeId !== undefined ? { scopeId } : {}),
-            limit,
-        });
-        const hydrated = await Promise.all(matched.map((item) => this.store.get(item.id)));
-        return hydrated.filter((s) => s !== null);
-    }
-    /** Index entries only — no instructions. For discovery/listing. */
-    async list(scopeId) {
-        const effectiveScopeId = scopeId ?? this.config.defaultScopeId;
-        const index = await this.getIndex();
-        return filterSkillIndex(index, {
-            ...(effectiveScopeId !== undefined ? { scopeId: effectiveScopeId } : {}),
-        });
-    }
-    /** Fetch one skill by id, falling back to name lookup. */
-    async get(idOrName) {
-        const byId = await this.store.get(idOrName);
-        if (byId) {
-            return byId;
-        }
-        const index = await this.getIndex();
-        // Prefer an active skill when resolving by name: a soft-deleted skill and a
-        // later same-named active skill can coexist in the index, so a bare
-        // name-find would resolve non-deterministically to the stale deprecated one
-        // across store backends. Fall back to any match only when no active skill
-        // carries the name.
-        //
-        // Matched case-insensitively to agree with assertNameAvailable, which
-        // enforces uniqueness that way: names differing only in case cannot
-        // coexist, so a case-sensitive lookup could only fail to find a skill that
-        // is definitively there (`get("DEPLOY")` returned null for "deploy").
-        const wanted = idOrName.toLowerCase();
-        const entry = index.find((item) => item.name.toLowerCase() === wanted &&
-            (item.status ?? "active") === "active") ?? index.find((item) => item.name.toLowerCase() === wanted);
-        return entry ? this.store.get(entry.id) : null;
-    }
-    /**
-     * Render the system-prompt skills index for one call, or null when
-     * nothing is visible. Never includes instructions.
-     */
-    async buildPromptIndex(options) {
-        const items = await this.visibleItems(options);
-        return formatSkillsPromptIndex(items, this.config.promptIndexMaxItems ?? DEFAULT_PROMPT_INDEX_MAX_ITEMS);
-    }
-    /**
-     * Render the `<available_skills>` block for the use_skill tool
-     * description ("tool" discovery mode), or null when nothing is visible.
-     * Bounded by listingBudgetChars; entries are never dropped.
-     */
-    async buildToolListing(options) {
-        const items = await this.visibleItems(options);
-        return renderSkillListing(items, this.config.listingBudgetChars ?? DEFAULT_LISTING_BUDGET_CHARS);
-    }
-    /** Visible (active, scope- and tag-filtered) index entries for one call. */
-    async visibleItems(options) {
-        let items = await this.list(options?.scopeId);
-        if (options?.tags && options.tags.length > 0) {
-            const wanted = options.tags.map((t) => t.toLowerCase());
-            items = items.filter((item) => (item.tags ?? []).some((t) => wanted.includes(t.toLowerCase())));
-        }
-        return items;
-    }
-    /**
-     * Read an auxiliary resource file bundled with a skill. Paths are
-     * relative to the skill; traversal segments are rejected. Null when the
-     * skill, the resource, or store resource support is absent.
-     */
-    async getResource(idOrName, resourcePath) {
-        const normalized = resourcePath.replace(/\\/g, "/");
-        if (normalized.startsWith("/") ||
-            normalized.split("/").some((segment) => segment === "..")) {
-            throw new Error(`Invalid resource path "${resourcePath}" — must be relative to the skill directory`);
-        }
-        if (!this.store.getResource) {
-            return null;
-        }
-        const skill = await this.get(idOrName);
-        if (!skill) {
-            return null;
-        }
-        return this.store.getResource(skill.id, normalized);
-    }
-    /**
-     * Whether skill create/update/delete is enabled on this instance. Gates the
-     * LLM-facing `skill_*` tools (registration) and the server REST mutation
-     * routes. Direct programmatic `requestMutation` calls are intentionally not
-     * gated, so a host can still seed skills at startup.
-     */
-    get mutationsAllowed() {
-        return this.config.allowMutations ?? false;
-    }
-    /**
-     * Gate a proposed mutation through the host's onMutationRequest hook,
-     * then apply it when approved. No hook configured means direct apply
-     * (the tools themselves are already gated by allowMutations).
-     */
-    async requestMutation(action) {
-        let decision = { outcome: "approved" };
-        if (this.config.onMutationRequest) {
-            decision = await this.config.onMutationRequest(action);
-        }
-        if (decision.outcome !== "approved") {
-            return { decision };
-        }
-        // Serialize writes within this process so the name-uniqueness check and
-        // the store write can never interleave across concurrent mutations.
-        // Cross-process races remain possible with plain-object stores (S3,
-        // Redis) — hosts needing strict global uniqueness should serialize via
-        // their onMutationRequest gate; the S3 index additionally self-heals.
-        const run = this.mutationQueue.then(() => this.applyMutation(action));
-        this.mutationQueue = run.catch(() => undefined);
-        const skill = await run;
-        return { decision, ...(skill ? { skill } : {}) };
-    }
-    async applyMutation(action) {
-        const now = new Date().toISOString();
-        if (action.type === "create") {
-            await this.assertNameAvailable(action.skill.name);
-            const skill = {
-                id: randomUUID(),
-                version: 1,
-                status: "active",
-                createdAt: now,
-                updatedAt: now,
-                ...action.skill,
-            };
-            assertScopeConsistent(skill);
-            await this.store.put(skill);
-            this.invalidateIndex();
-            logger.info("[SkillsManager] Skill created", {
-                skillId: skill.id,
-                name: skill.name,
-            });
-            return skill;
-        }
-        if (action.type === "update") {
-            const existing = await this.get(action.skillId);
-            if (!existing) {
-                throw new Error(`Skill "${action.skillId}" not found`);
-            }
-            if (action.patch.name && action.patch.name !== existing.name) {
-                await this.assertNameAvailable(action.patch.name, existing.id);
-            }
-            const updated = {
-                ...existing,
-                ...definedFields(action.patch),
-                id: existing.id,
-                version: (existing.version ?? 1) + 1,
-                updatedAt: now,
-            };
-            assertScopeConsistent(updated);
-            await this.store.put(updated);
-            this.invalidateIndex();
-            logger.info("[SkillsManager] Skill updated", {
-                skillId: updated.id,
-                version: updated.version,
-            });
-            return updated;
-        }
-        // delete — soft: mark deprecated so the skill drops out of active
-        // listings but stays in storage for audit/undo.
-        const existing = await this.get(action.skillId);
-        if (!existing) {
-            throw new Error(`Skill "${action.skillId}" not found`);
-        }
-        if (existing.status === "deprecated") {
-            throw new Error(`Skill "${existing.name}" is already deleted`);
-        }
-        const deprecated = {
-            ...existing,
-            status: "deprecated",
-            updatedAt: now,
-        };
-        await this.store.put(deprecated);
-        this.invalidateIndex();
-        logger.info("[SkillsManager] Skill deprecated", {
-            skillId: existing.id,
-            name: existing.name,
-        });
-        return deprecated;
-    }
-    async assertNameAvailable(name, excludeId) {
-        const index = await this.getIndex(true);
-        // Deliberately NOT filtered to active (#1139). Soft-delete only flips
-        // status to "deprecated" — the entry stays in the index, so allowing a new
-        // skill to take the name left two entries sharing it. Every name-based
-        // lookup (CLI `skills show/delete <name>`, the skill_update/skill_delete
-        // tools, the `:id`-or-name REST routes) then had to guess which one the
-        // caller meant, and iteration order differs across store backends.
-        //
-        // A deprecated skill's name therefore stays reserved. Reusing it requires
-        // hard-deleting the old skill first, which is the explicit choice the
-        // ambiguity demands.
-        const clash = index.find((item) => item.id !== excludeId && item.name.toLowerCase() === name.toLowerCase());
-        if (clash) {
-            const suffix = (clash.status ?? "active") === "active"
-                ? ""
-                : ` (that name belongs to a deprecated skill, id ${clash.id}; ` +
-                    `remove it before reusing the name)`;
-            throw new Error(`A skill named "${name}" already exists${suffix}`);
-        }
-    }
-}
-/**
- * A scoped skill without scopeIds can never match anything — reject the
- * write instead of persisting an unmatchable skill. Validated post-merge so
- * both create and patch-style update paths are covered.
- */
-function assertScopeConsistent(skill) {
-    if (skill.scope === "scoped" && (skill.scopeIds ?? []).length === 0) {
-        throw new Error('A skill with scope "scoped" must have at least one entry in scopeIds');
-    }
-}
-/** Shallow-copy only the defined fields of a patch (undefined must not overwrite). */
-function definedFields(patch) {
-    return Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined));
-}
-//# sourceMappingURL=skillsManager.js.map

package/dist/lib/tasks/autoresearchTaskExecutor.d.ts

@@ -1,31 +0,0 @@
-/**
- * Autoresearch task executor — bridges TaskManager with the
- * autoresearch experiment loop.
- *
- * Each tick:
- * 1. Loads/creates a ResearchWorker for the task's tag
- * 2. Gets the phase-appropriate tool filter
- * 3. Calls NeuroLink.generate() with research tools + prompt
- * 4. Advances phase based on which tools the AI called
- * 5. Returns a TaskRunResult
- *
- * Workers are cached by tag to avoid re-initialization on each tick.
- * Forwards the NeuroLink emitter to each worker for lifecycle events.
- */
-import type { AutoresearchEmitter, NeuroLinkExecutable, Task, TaskRunResult } from "../types/index.js";
-/**
- * Clear all cached workers. Called by TaskManager.shutdown().
- */
-export declare function clearWorkerCache(): void;
-/**
- * Execute one autoresearch tick for a task.
- *
- * Returns a TaskRunResult-shaped object.
- * If the task is missing autoresearch config, returns an error result
- * instead of throwing (so the scheduler can record the failure).
- *
- * @param emitter - Optional emitter to forward autoresearch lifecycle events
- */
-export declare function executeAutoresearchTick(task: Task & {
-    autoresearch?: unknown;
-}, neurolink: NeuroLinkExecutable, emitter?: AutoresearchEmitter): Promise<TaskRunResult>;

package/dist/lib/tasks/autoresearchTaskExecutor.js

@@ -1,304 +0,0 @@
-/**
- * Autoresearch task executor — bridges TaskManager with the
- * autoresearch experiment loop.
- *
- * Each tick:
- * 1. Loads/creates a ResearchWorker for the task's tag
- * 2. Gets the phase-appropriate tool filter
- * 3. Calls NeuroLink.generate() with research tools + prompt
- * 4. Advances phase based on which tools the AI called
- * 5. Returns a TaskRunResult
- *
- * Workers are cached by tag to avoid re-initialization on each tick.
- * Forwards the NeuroLink emitter to each worker for lifecycle events.
- */
-import { ResearchWorker } from "../autoresearch/worker.js";
-import { withTimeout } from "../utils/errorHandling.js";
-import { logger } from "../utils/logger.js";
-import { toolExecutionRecordsToToolCalls } from "../utils/transformationUtils.js";
-// ── Worker cache ────────────────────────────────────────
-const workerCache = new Map();
-/**
- * Clear all cached workers. Called by TaskManager.shutdown().
- */
-export function clearWorkerCache() {
-    workerCache.clear();
-    logger.debug("[AutoresearchExecutor] Worker cache cleared");
-}
-// ── Phase advancement ──────────────────────────────────
-/**
- * Determine the next phase based on which tools the AI called.
- *
- * The worker path (`runExperimentCycle`) drives phases internally.
- * The task path must replicate that advancement here. The mapping:
- *
- *   bootstrap → (get_context called) → propose
- *   propose   → (read_file called)   → edit
- *   edit      → (write_candidate)    → commit
- *   commit    → (commit_candidate)   → run
- *   run       → (run_experiment)     → evaluate
- *   evaluate  → (parse_log)          → record
- *   record    → (record called)      → accept_or_revert
- *   accept_or_revert → (accept/revert) → propose
- *
- * Returns null if no advancement is indicated (e.g. no recognised tools called).
- */
-function inferNextPhase(currentPhase, calledTools) {
-    if (calledTools.length === 0) {
-        return null;
-    }
-    // Compute phase advancement per-tool against the running accumulated phase
-    function phaseAfterTool(toolName, phase) {
-        switch (toolName) {
-            case "research_get_context":
-                return phase === "bootstrap" || phase === "propose" ? "propose" : phase;
-            case "research_read_file":
-                return phase === "propose" ? "edit" : phase;
-            case "research_write_candidate":
-                return "commit";
-            case "research_commit_candidate":
-                return "run";
-            case "research_run_experiment":
-                return "evaluate";
-            case "research_parse_log":
-                return "record";
-            case "research_record":
-                return "accept_or_revert";
-            case "research_accept":
-                return "propose";
-            case "research_revert":
-                return "propose";
-            default:
-                return phase; // informational tools don't advance
-        }
-    }
-    // Walk the called tools in order, accumulating phase progression
-    let nextPhase = currentPhase;
-    for (const toolName of calledTools) {
-        nextPhase = phaseAfterTool(toolName, nextPhase);
-    }
-    return nextPhase !== currentPhase ? nextPhase : null;
-}
-/**
- * Get or create a ResearchWorker for the given task.
- * When an emitter is provided, it is injected into the worker
- * so that autoresearch:* events flow through the central event bus.
- */
-async function getOrCreateWorker(task, emitter) {
-    const tag = `task-${task.id}`;
-    const cached = workerCache.get(tag);
-    if (cached) {
-        // Re-inject emitter in case it changed (e.g. after re-initialization)
-        if (emitter) {
-            cached.setEmitter(emitter);
-        }
-        // Attempt to resume existing state
-        try {
-            await cached.resume();
-            return cached;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            // Only re-initialize if state is genuinely missing; surface other errors
-            if (msg.includes("STATE_NOT_FOUND") || msg.includes("No state file")) {
-                workerCache.delete(tag);
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-    // Validated at caller (line 184 returns early if missing)
-    const config = task.autoresearch;
-    const worker = new ResearchWorker({
-        repoPath: config.repoPath,
-        mutablePaths: config.mutablePaths,
-        runCommand: config.runCommand,
-        metric: config.metric,
-        ...(config.immutablePaths ? { immutablePaths: config.immutablePaths } : {}),
-        ...(config.timeoutMs ? { timeoutMs: config.timeoutMs } : {}),
-        ...(config.provider ? { provider: config.provider } : {}),
-        ...(config.model ? { model: config.model } : {}),
-        ...(config.thinkingLevel ? { thinkingLevel: config.thinkingLevel } : {}),
-        ...(config.maxExperiments ? { maxExperiments: config.maxExperiments } : {}),
-        // Forward artifact layout fields so scheduled runs match standalone config
-        ...(config.programPath ? { programPath: config.programPath } : {}),
-        ...(config.resultsPath ? { resultsPath: config.resultsPath } : {}),
-        ...(config.statePath ? { statePath: config.statePath } : {}),
-        ...(config.logPath ? { logPath: config.logPath } : {}),
-        ...(config.branchPrefix ? { branchPrefix: config.branchPrefix } : {}),
-        ...(config.memoryMetric ? { memoryMetric: config.memoryMetric } : {}),
-    });
-    // Inject emitter before initialization so init events are captured
-    if (emitter) {
-        worker.setEmitter(emitter);
-    }
-    // Try resuming existing state first; only initialize if state is genuinely missing
-    try {
-        await worker.resume();
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        if (msg.includes("STATE_NOT_FOUND") || msg.includes("No state file")) {
-            await worker.initialize(tag);
-        }
-        else {
-            throw err;
-        }
-    }
-    workerCache.set(tag, worker);
-    return worker;
-}
-/**
- * Execute one autoresearch tick for a task.
- *
- * Returns a TaskRunResult-shaped object.
- * If the task is missing autoresearch config, returns an error result
- * instead of throwing (so the scheduler can record the failure).
- *
- * @param emitter - Optional emitter to forward autoresearch lifecycle events
- */
-export async function executeAutoresearchTick(task, neurolink, emitter) {
-    const startTime = Date.now();
-    const runId = `ar_${Date.now()}`;
-    // Validate config presence
-    if (!task.autoresearch) {
-        return {
-            taskId: task.id,
-            runId,
-            status: "error",
-            error: `Task ${task.id} has type=autoresearch but no autoresearch config`,
-            durationMs: Date.now() - startTime,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    try {
-        const worker = await getOrCreateWorker(task, emitter);
-        // Get phase-appropriate tools and filter
-        const tools = worker.getTools();
-        const toolFilter = await worker.getToolFilterForCurrentPhase();
-        const systemPrompt = await worker.getSystemPrompt();
-        const cyclePrompt = await worker.getCyclePrompt();
-        // Register research tools on NeuroLink if it supports registerTool
-        const sdk = neurolink;
-        if (typeof sdk.registerTool === "function") {
-            for (const [name, tool] of Object.entries(tools)) {
-                sdk.registerTool(name, tool);
-            }
-        }
-        // Get the current phase's forced tool (if any)
-        const phasePolicy = await worker.getPhaseToolPolicy();
-        // Extract provider/model from autoresearch config
-        const arConfig = task.autoresearch;
-        // Create an AbortController so the tick respects the task timeout.
-        // Each tick should complete within a bounded time; 20 tool-call steps
-        // is enough for one explore→write→experiment→record cycle.
-        const tickTimeoutMs = (task.timeout ?? 120_000);
-        const abortController = new AbortController();
-        const abortTimer = setTimeout(() => abortController.abort(), tickTimeoutMs);
-        // Call generate
-        const generateOptions = {
-            input: { text: cyclePrompt },
-            systemPrompt,
-            tools: true,
-            skipToolPromptInjection: true,
-            maxSteps: 20, // Bound tool-call steps per tick to avoid runaway loops
-            abortSignal: abortController.signal,
-            // Forward provider/model from autoresearch config
-            ...(arConfig?.provider ? { provider: arConfig.provider } : {}),
-            ...(arConfig?.model ? { model: arConfig.model } : {}),
-            ...(arConfig?.thinkingLevel || task.thinkingLevel
-                ? {
-                    thinkingConfig: {
-                        thinkingLevel: arConfig?.thinkingLevel ?? task.thinkingLevel,
-                    },
-                }
-                : {}),
-            ...(task.timeout ? { timeout: task.timeout } : {}),
-            // Phase tool restrictions
-            toolFilter,
-            // Use prepareStep to force tool only on first step, not all steps
-            ...(phasePolicy.forcedTool
-                ? {
-                    prepareStep: ({ stepNumber }) => {
-                        if (stepNumber === 0 && phasePolicy.forcedTool) {
-                            return {
-                                toolChoice: {
-                                    type: "tool",
-                                    toolName: phasePolicy.forcedTool,
-                                },
-                            };
-                        }
-                        return {};
-                    },
-                }
-                : {}),
-            // Observability
-            requestId: runId,
-            ...(task.metadata?.maxBudgetUsd
-                ? { maxBudgetUsd: task.metadata.maxBudgetUsd }
-                : {}),
-        };
-        let result;
-        try {
-            result = await withTimeout(neurolink.generate(generateOptions), tickTimeoutMs, new Error(`Autoresearch tick exceeded ${tickTimeoutMs}ms timeout`));
-        }
-        finally {
-            clearTimeout(abortTimer);
-        }
-        // ── Phase advancement ──────────────────────────────
-        // The deterministic worker path (runExperimentCycle) advances
-        // phases internally.  The task path must do it here, based on
-        // which tools the AI actually called this tick.
-        const calledTools = (result.toolExecutions ?? [])
-            .map((te) => {
-            const t = te;
-            return typeof t.toolName === "string"
-                ? t.toolName
-                : typeof t.name === "string"
-                    ? t.name
-                    : "";
-        })
-            .filter(Boolean);
-        const currentState = await worker.getState();
-        const currentPhase = currentState?.currentPhase ?? "bootstrap";
-        const nextPhase = inferNextPhase(currentPhase, calledTools);
-        if (nextPhase) {
-            await worker.advancePhase(nextPhase);
-            logger.debug("[AutoresearchExecutor] Phase advanced", {
-                from: currentPhase,
-                to: nextPhase,
-                calledTools,
-            });
-        }
-        return {
-            taskId: task.id,
-            runId,
-            status: "success",
-            output: result.content,
-            toolCalls: toolExecutionRecordsToToolCalls(result.toolExecutions),
-            tokensUsed: result.usage
-                ? { input: result.usage.input ?? 0, output: result.usage.output ?? 0 }
-                : undefined,
-            durationMs: Date.now() - startTime,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        logger.error("[AutoresearchExecutor] Tick failed", {
-            taskId: task.id,
-            runId,
-            error: msg,
-        });
-        return {
-            taskId: task.id,
-            runId,
-            status: "error",
-            error: msg,
-            durationMs: Date.now() - startTime,
-            timestamp: new Date().toISOString(),
-        };
-    }
-}
-//# sourceMappingURL=autoresearchTaskExecutor.js.map

package/dist/lib/tasks/backends/bullmqBackend.d.ts

@@ -1,33 +0,0 @@
-/**
- * BullMQ Backend — Production-grade task scheduling via Redis.
- *
- * - Cron tasks → BullMQ repeatable jobs with cron pattern
- * - Interval tasks → BullMQ repeatable jobs with `every` option
- * - One-shot tasks → BullMQ delayed jobs
- * - Survives process restarts (Redis-persisted)
- */
-import { type Task, type TaskBackend, type TaskExecutorFn, type TaskManagerConfig } from "../../types/index.js";
-export declare class BullMQBackend implements TaskBackend {
-    readonly name = "bullmq";
-    private queue;
-    private worker;
-    private executors;
-    private config;
-    constructor(config: TaskManagerConfig);
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    schedule(task: Task, executor: TaskExecutorFn): Promise<void>;
-    cancel(taskId: string): Promise<void>;
-    pause(taskId: string): Promise<void>;
-    resume(taskId: string): Promise<void>;
-    isHealthy(): Promise<boolean>;
-    /**
-     * Returns a connection options object for BullMQ / ioredis.
-     * When a URL is provided we parse it fully, preserving TLS (`rediss://`),
-     * ACL username, password, db index, and any query-string parameters so
-     * nothing is silently dropped.
-     */
-    private getConnectionConfig;
-    private ensureInitialized;
-    private getQueue;
-}