@juspay/neurolink 9.40.0 → 9.42.0

package/dist/cli/commands/mcp.js

@@ -565,6 +565,7 @@ export class MCPCommandFactory {
                 ? null
                 : ora("Testing MCP server connections...").start();
             const sdk = new NeuroLink();
+            await sdk.getMCPStatus();
             let serversToTest = await sdk.listMCPServers();
             if (targetServer) {
                 serversToTest = serversToTest.filter((s) => s.name === targetServer);
@@ -654,6 +655,7 @@ export class MCPCommandFactory {
                 }
             }
             const sdk = new NeuroLink();
+            await sdk.getMCPStatus();
             // Check if server exists and is connected
             const allServers = await sdk.listMCPServers();
             const server = allServers.find((s) => s.name === serverName);
@@ -762,6 +764,7 @@ export class MCPCommandFactory {
                 process.exit(1);
             }
             const sdk = new NeuroLink();
+            await sdk.getMCPStatus();
             const allServers = await sdk.listMCPServers();
             const server = allServers.find((s) => s.name === serverName);
             if (!server) {

package/dist/cli/commands/proxy.d.ts

@@ -10,10 +10,11 @@
  * (generate/stream), with an optional ModelRouter for model remapping.
  */
 import type { CommandModule } from "yargs";
-import type { ProxyStartArgs, ProxyStatusArgs, ProxyGuardArgs } from "../../lib/types/index.js";
+import type { ProxyStartArgs, ProxyStatusArgs, ProxyGuardArgs, ProxyTelemetryArgs } from "../../lib/types/index.js";
 export declare function mapClaudeErrorTypeToStatus(errorType?: string): number;
 export declare const proxyStartCommand: CommandModule<object, ProxyStartArgs>;
 export declare const proxyStatusCommand: CommandModule<object, ProxyStatusArgs>;
+export declare const proxyTelemetryCommand: CommandModule<object, ProxyTelemetryArgs>;
 export declare const proxyGuardCommand: CommandModule<object, ProxyGuardArgs>;
 export declare const proxySetupCommand: CommandModule;
 export declare const proxyInstallCommand: CommandModule;

package/dist/cli/commands/proxy.js

@@ -16,9 +16,12 @@ import chalk from "chalk";
 import ora from "ora";
 import { logger } from "../../lib/utils/logger.js";
 import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serverUtils.js";
+import { loadProxyEnvFile, resolveProxyEnvFile, } from "../../lib/proxy/proxyEnv.js";
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 const _require = createRequire(import.meta.url);
 const { version: PROXY_VERSION } = _require("../../../package.json");
+const PROXY_TELEMETRY_SCRIPT_PATH = fileURLToPath(new URL("../../../scripts/observability/manage-local-openobserve.sh", import.meta.url));
 // =============================================================================
 // STATE MANAGEMENT
 // =============================================================================
@@ -220,6 +223,32 @@ function spawnFailOpenGuard(host, port, parentPid) {
         return undefined;
     }
 }
+async function runProxyTelemetryManager(command) {
+    const { existsSync } = await import("fs");
+    if (!existsSync(PROXY_TELEMETRY_SCRIPT_PATH)) {
+        throw new Error("Proxy telemetry helper files were not found in this installation. Reinstall NeuroLink with observability assets included.");
+    }
+    await new Promise((resolve, reject) => {
+        const child = spawn("bash", [PROXY_TELEMETRY_SCRIPT_PATH, command], {
+            stdio: "inherit",
+            env: process.env,
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                reject(new Error(`proxy telemetry ${command} terminated by signal ${signal}`));
+                return;
+            }
+            if (code !== 0) {
+                reject(new Error(`proxy telemetry ${command} exited with code ${code ?? 1}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}
 // =============================================================================
 // STARTUP BANNER
 // =============================================================================
@@ -313,6 +342,16 @@ export const proxyStartCommand = {
             alias: "c",
             description: "Path to proxy config file (YAML/JSON)",
             defaultDescription: "~/.neurolink/proxy-config.yaml",
+        })
+            .option("env-file", {
+            type: "string",
+            alias: "envFile",
+            description: "Path to proxy provider env file (overrides cwd .env for the proxy process)",
+        })
+            .option("passthrough", {
+            type: "boolean",
+            default: false,
+            description: "Run in transparent passthrough mode (no retry, no rotation, no polyfill)",
         })
             .example("neurolink proxy start", "Start proxy on default port 55669 with fill-first strategy")
             .example("neurolink proxy start -p 8080 -s fill-first", "Start proxy on port 8080 with fill-first")
@@ -357,6 +396,22 @@ export const proxyStartCommand = {
             // -----------------------------------------------------------------
             // 1. Create NeuroLink instance — reads all env vars automatically
             // -----------------------------------------------------------------
+            let loadedEnvFile;
+            try {
+                const envResult = await loadProxyEnvFile({
+                    explicitEnvFile: argv.envFile,
+                });
+                loadedEnvFile = envResult.path;
+                if (spinner && loadedEnvFile) {
+                    spinner.text = `Loaded proxy env from ${loadedEnvFile}`;
+                }
+            }
+            catch (envError) {
+                if (spinner) {
+                    spinner.fail(chalk.red(envError instanceof Error ? envError.message : String(envError)));
+                }
+                process.exit(1);
+            }
             // Skip MCP initialization for proxy — tools come from Claude Code, not MCP servers
             process.env.NEUROLINK_SKIP_MCP = "true";
             const { NeuroLink } = await import("../../lib/neurolink.js");
@@ -433,15 +488,24 @@ export const proxyStartCommand = {
                     },
                 }, 502);
             });
-            const routeGroup = createClaudeProxyRoutes(modelRouter, "", strategy);
+            const passthrough = argv.passthrough ?? false;
+            const routeGroup = createClaudeProxyRoutes(modelRouter, "", strategy, passthrough);
             // Register proxy routes — inject NeuroLink into ServerContext
             for (const route of routeGroup.routes) {
                 const method = route.method.toLowerCase();
                 app[method](route.path, async (c) => {
                     const emptyBody = {};
-                    const body = method === "post"
-                        ? await c.req.json().catch(() => emptyBody)
-                        : undefined;
+                    let body;
+                    let rawBody;
+                    if (method === "post") {
+                        rawBody = await c.req.text().catch(() => undefined);
+                        try {
+                            body = rawBody ? JSON.parse(rawBody) : emptyBody;
+                        }
+                        catch {
+                            body = emptyBody;
+                        }
+                    }
                     // Log incoming request
                     const model = body?.model ?? "-";
                     const stream = body?.stream
@@ -461,6 +525,7 @@ export const proxyStartCommand = {
                         query: Object.fromEntries(new URL(c.req.url).searchParams.entries()),
                         params: c.req.param(),
                         body,
+                        rawBody, // Preserve original bytes for passthrough mode
                         neurolink, // NeuroLink instance for generate/stream
                         toolRegistry: neurolink.getToolRegistry(),
                         timestamp: Date.now(),
@@ -564,6 +629,7 @@ export const proxyStartCommand = {
                     uptime: process.uptime(),
                     version: PROXY_VERSION,
                     stats: {
+                        totalAttempts: stats.totalAttempts,
                         totalRequests: stats.totalRequests,
                         totalSuccess: stats.totalSuccess,
                         totalErrors: stats.totalErrors,
@@ -571,7 +637,8 @@ export const proxyStartCommand = {
                         accounts: Object.values(stats.accounts).map((a) => ({
                             label: a.label,
                             type: a.type,
-                            requests: a.requestCount,
+                            attempts: a.attemptCount,
+                            requests: a.attemptCount,
                             success: a.successCount,
                             errors: a.errorCount,
                             rateLimits: a.rateLimitCount,
@@ -583,7 +650,55 @@ export const proxyStartCommand = {
                 });
             });
             // -----------------------------------------------------------------
-            // 5. Start listening
+            // 5. Initialize OpenTelemetry for proxy observability
+            // -----------------------------------------------------------------
+            try {
+                const otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+                if (!process.env.OTEL_SERVICE_NAME) {
+                    process.env.OTEL_SERVICE_NAME = "neurolink-proxy";
+                }
+                // Merge resource attributes (preserving any existing ones)
+                process.env.OTEL_RESOURCE_ATTRIBUTES = [
+                    `service.name=neurolink-proxy`,
+                    `service.version=${PROXY_VERSION}`,
+                    `deployment.environment=local`,
+                    process.env.OTEL_RESOURCE_ATTRIBUTES,
+                ]
+                    .filter(Boolean)
+                    .join(",");
+                const { initializeOpenTelemetry, isOpenTelemetryInitialized } = await import("../../lib/services/server/ai/observability/instrumentation.js");
+                const { buildObservabilityConfigFromEnv } = await import("../../lib/utils/observabilityHelpers.js");
+                if (!isOpenTelemetryInitialized()) {
+                    const observabilityConfig = buildObservabilityConfigFromEnv();
+                    const langfuseConfig = observabilityConfig?.langfuse;
+                    const langfuseEnabled = langfuseConfig?.enabled === true;
+                    initializeOpenTelemetry({
+                        enabled: langfuseEnabled,
+                        publicKey: langfuseConfig?.publicKey || "",
+                        secretKey: langfuseConfig?.secretKey || "",
+                        baseUrl: langfuseConfig?.baseUrl,
+                        environment: "proxy",
+                        release: PROXY_VERSION,
+                        userId: "neurolink-proxy",
+                        autoDetectOperationName: true,
+                    });
+                    if (langfuseEnabled) {
+                        logger.always(`[proxy] Langfuse enabled — exporting to ${langfuseConfig.baseUrl || "https://cloud.langfuse.com"} (environment=proxy)`);
+                    }
+                    if (otlpEndpoint) {
+                        logger.always(`[proxy] OTLP exporter enabled — exporting to ${otlpEndpoint} (service.name=neurolink-proxy)`);
+                    }
+                    if (!langfuseEnabled && !otlpEndpoint) {
+                        logger.always("[proxy] OpenTelemetry exporters disabled — set OTEL_EXPORTER_OTLP_ENDPOINT or Langfuse credentials to enable proxy observability");
+                    }
+                }
+            }
+            catch (otelError) {
+                // OTel is non-critical — proxy must still work without it
+                logger.debug(`[proxy] OpenTelemetry init failed (non-fatal): ${otelError instanceof Error ? otelError.message : String(otelError)}`);
+            }
+            // -----------------------------------------------------------------
+            // 6. Start listening
             // -----------------------------------------------------------------
             const port = argv.port ?? 55669;
             const host = argv.host ?? "127.0.0.1";
@@ -608,9 +723,13 @@ export const proxyStartCommand = {
                 host,
                 strategy,
                 startTime: new Date().toISOString(),
+                envFile: loadedEnvFile,
                 fallbackChain,
                 guardPid,
-                managedBy: "manual",
+                managedBy: process.platform === "darwin" && process.ppid === 1
+                    ? "launchd"
+                    : "manual",
+                passthrough,
             };
             saveProxyState(state);
             if (spinner) {
@@ -619,6 +738,10 @@ export const proxyStartCommand = {
             const normalizedHost = host === "0.0.0.0" ? "localhost" : host;
             const url = `http://${normalizedHost}:${port}`;
             printProxyBanner(url, strategy);
+            logger.always(`  ${chalk.bold("Mode:")}       ${chalk.cyan(passthrough ? "passthrough" : "full")}`);
+            if (loadedEnvFile) {
+                logger.always(`  ${chalk.bold("Env File:")}   ${chalk.cyan(loadedEnvFile)}`);
+            }
             // Auto-configure Claude Code — use the normalized URL (localhost, not 0.0.0.0)
             try {
                 await setClaudeProxySettings(url);
@@ -630,7 +753,7 @@ export const proxyStartCommand = {
                     (e instanceof Error ? e.message : String(e)));
             }
             // -----------------------------------------------------------------
-            // 6. Background token refresh (every 30 seconds)
+            // 7. Background token refresh (every 30 seconds)
             // -----------------------------------------------------------------
             const { needsRefresh, refreshToken, persistTokens } = await import("../../lib/proxy/tokenRefresh.js");
             const { tokenStore } = await import("../../lib/auth/tokenStore.js");
@@ -697,12 +820,21 @@ export const proxyStartCommand = {
                 cleanupLogs(7, 500);
             }, 60 * 60 * 1000);
             // -----------------------------------------------------------------
-            // 7. Graceful shutdown
+            // 8. Graceful shutdown
             // -----------------------------------------------------------------
             const shutdown = async (signal) => {
                 clearInterval(refreshInterval);
                 clearInterval(logCleanupInterval);
                 logger.always(`\nShutting down proxy (${signal})...`);
+                // Flush and shutdown OpenTelemetry before closing the server
+                try {
+                    const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../lib/services/server/ai/observability/instrumentation.js");
+                    await flushOpenTelemetry();
+                    await shutdownOpenTelemetry();
+                }
+                catch {
+                    /* non-fatal — proxy shutdown must not block on OTel */
+                }
                 // Only clear Claude settings on user-initiated stop (SIGINT).
                 // On SIGTERM (launchd restart cycle), leave settings intact so
                 // the restarted proxy picks up seamlessly.
@@ -746,7 +878,10 @@ export const proxyStartCommand = {
 };
 function printStatusStats(stats) {
     console.info(`\n  Stats:`);
-    console.info(`    Requests:    ${stats.totalRequests} total, ${stats.totalSuccess} success, ${stats.totalErrors} errors`);
+    if (stats.totalAttempts !== undefined) {
+        console.info(`    Attempts:    ${stats.totalAttempts}`);
+    }
+    console.info(`    Completed:   ${stats.totalRequests} total, ${stats.totalSuccess} success, ${stats.totalErrors} errors`);
     console.info(`    Rate limits: ${stats.totalRateLimits}`);
     if (stats.accounts?.length) {
         console.info(`\n  Accounts:`);
@@ -754,7 +889,11 @@ function printStatusStats(stats) {
             const acctStatus = a.cooling
                 ? chalk.red("cooling")
                 : chalk.green("active");
-            console.info(`    ${a.label.padEnd(20)} ${a.type.padEnd(8)} ${String(a.requests).padEnd(6)} reqs  ${acctStatus}`);
+            const attempts = a.attempts ?? a.requests ?? 0;
+            const success = a.success ?? 0;
+            const errors = a.errors ?? 0;
+            const rateLimits = a.rateLimits ?? 0;
+            console.info(`    ${a.label.padEnd(20)} ${a.type.padEnd(8)} ${String(attempts).padEnd(6)} attempts  ${String(success).padEnd(6)} success  ${String(errors).padEnd(6)} errors  ${String(rateLimits).padEnd(6)} rl  ${acctStatus}`);
         }
     }
 }
@@ -793,6 +932,7 @@ export const proxyStatusCommand = {
                 uptime: null,
                 startTime: null,
                 url: null,
+                envFile: null,
                 fallbackChain: null,
             };
             if (state && isProcessRunning(state.pid)) {
@@ -804,10 +944,25 @@ export const proxyStatusCommand = {
                 status.startTime = state.startTime;
                 status.uptime = Date.now() - new Date(state.startTime).getTime();
                 status.url = `http://${state.host === "0.0.0.0" ? "localhost" : state.host}:${state.port}`;
+                status.envFile = state.envFile ?? null;
                 status.fallbackChain = state.fallbackChain ?? null;
             }
+            // Fetch live stats before rendering (JSON or text)
+            let liveStats = null;
+            if (status.running && status.url) {
+                try {
+                    const statusResp = await fetch(`${status.url}/status`);
+                    if (statusResp.ok) {
+                        const statusData = (await statusResp.json());
+                        liveStats = statusData.stats;
+                    }
+                }
+                catch {
+                    // Non-fatal — live stats unavailable
+                }
+            }
             if (argv.format === "json") {
-                logger.always(JSON.stringify(status, null, 2));
+                logger.always(JSON.stringify({ ...status, stats: liveStats }, null, 2));
                 return;
             }
             // Text format
@@ -822,6 +977,9 @@ export const proxyStatusCommand = {
                 logger.always(`  ${chalk.bold("Strategy:")}   ${chalk.cyan(status.strategy)}`);
                 logger.always(`  ${chalk.bold("Started:")}    ${chalk.cyan(status.startTime)}`);
                 logger.always(`  ${chalk.bold("Uptime:")}     ${chalk.cyan(formatUptime(status.uptime ?? 0))}`);
+                if (status.envFile) {
+                    logger.always(`  ${chalk.bold("Env File:")}   ${chalk.cyan(status.envFile)}`);
+                }
                 // Display fallback chain if configured
                 if (status.fallbackChain && status.fallbackChain.length > 0) {
                     logger.always("");
@@ -875,6 +1033,58 @@ export const proxyStatusCommand = {
     },
 };
 // =============================================================================
+// PROXY TELEMETRY COMMAND
+// =============================================================================
+const PROXY_TELEMETRY_ACTIONS = [
+    "setup",
+    "start",
+    "stop",
+    "status",
+    "logs",
+    "import-dashboard",
+];
+export const proxyTelemetryCommand = {
+    command: "telemetry <action>",
+    describe: "Manage the local OpenObserve stack and dashboard for proxy observability",
+    builder: (yargs) => yargs
+        .positional("action", {
+        type: "string",
+        choices: [...PROXY_TELEMETRY_ACTIONS],
+        describe: "Telemetry action: setup, start, stop, status, logs, or import-dashboard",
+    })
+        .option("quiet", {
+        type: "boolean",
+        alias: "q",
+        default: false,
+        description: "Suppress the local CLI spinner and delegate directly",
+    })
+        .example("neurolink proxy telemetry setup", "Start OpenObserve, start the OTEL collector, and import the dashboard")
+        .example("neurolink proxy telemetry start", "Start the local proxy telemetry stack without re-importing the dashboard")
+        .example("neurolink proxy telemetry stop", "Stop the local OpenObserve and OTEL collector containers"),
+    handler: async (argv) => {
+        const action = argv.action;
+        const spinner = argv.quiet
+            ? null
+            : ora(`Running proxy telemetry ${action}...`).start();
+        try {
+            if (spinner) {
+                spinner.stop();
+            }
+            await runProxyTelemetryManager(action);
+            if (spinner) {
+                spinner.succeed(`proxy telemetry ${action} completed`);
+            }
+        }
+        catch (error) {
+            if (spinner) {
+                spinner.fail(`proxy telemetry ${action} failed`);
+            }
+            logger.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+            process.exit(1);
+        }
+    },
+};
+// =============================================================================
 // PROXY FAIL-OPEN GUARD COMMAND (HIDDEN)
 // =============================================================================
 export const proxyGuardCommand = {
@@ -1152,6 +1362,11 @@ export const proxySetupCommand = {
             type: "boolean",
             default: false,
             description: "Skip service installation and start proxy in foreground instead",
+        })
+            .option("env-file", {
+            type: "string",
+            alias: "envFile",
+            description: "Path to proxy provider env file to persist for the proxy",
         })
             .example("neurolink proxy setup", "Full setup with defaults")
             .example("neurolink proxy setup -p 9000", "Setup on custom port")
@@ -1253,9 +1468,27 @@ export const proxySetupCommand = {
 // =============================================================================
 // PROXY INSTALL / UNINSTALL — launchd service (macOS)
 // =============================================================================
-function buildPlist(port, host) {
-    const nodeExec = process.execPath;
-    const entryScript = process.argv[1] ?? join(__dirname, "..", "index.js");
+function escapeXml(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function buildPlist(port, host, envFile, configFile) {
+    const nodeExec = escapeXml(process.execPath);
+    const entryScript = escapeXml(process.argv[1] ?? join(__dirname, "..", "index.js"));
+    const envFileArgs = envFile
+        ? `
+    <string>--env-file</string>
+    <string>${escapeXml(envFile)}</string>`
+        : "";
+    const configArgs = configFile
+        ? `
+    <string>--config</string>
+    <string>${escapeXml(configFile)}</string>`
+        : "";
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
   "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -1274,6 +1507,8 @@ function buildPlist(port, host) {
     <string>${port}</string>
     <string>--host</string>
     <string>${host}</string>
+${envFileArgs}
+${configArgs}
     <string>--quiet</string>
   </array>
 
@@ -1320,6 +1555,15 @@ export const proxyInstallCommand = {
             type: "string",
             default: "127.0.0.1",
             description: "Proxy host",
+        })
+            .option("env-file", {
+            type: "string",
+            alias: "envFile",
+            description: "Path to proxy provider env file to persist for the service",
+        })
+            .option("config", {
+            type: "string",
+            description: "Path to proxy routing config file to persist for the service",
         })
             .example("neurolink proxy install", "Install with defaults (port 55669)")
             .example("neurolink proxy install -p 9000", "Install on custom port");
@@ -1333,6 +1577,21 @@ export const proxyInstallCommand = {
             process.exit(1);
         }
         const { writeFileSync, mkdirSync, existsSync } = await import("fs");
+        const envResolution = resolveProxyEnvFile({
+            explicitEnvFile: argv.envFile,
+        });
+        const envFile = envResolution.path;
+        const explicitConfig = argv.config;
+        const configPath = explicitConfig ?? join(homedir(), ".neurolink", "proxy-config.yaml");
+        if (explicitConfig && !existsSync(configPath)) {
+            console.info(chalk.red(`Proxy config file not found: ${configPath}`));
+            process.exit(1);
+        }
+        const configFile = existsSync(configPath) ? configPath : undefined;
+        if (envFile && !existsSync(envFile)) {
+            console.info(chalk.red(`Proxy env file not found: ${envFile}`));
+            process.exit(1);
+        }
         const logsDir = join(homedir(), ".neurolink", "logs");
         if (!existsSync(logsDir)) {
             mkdirSync(logsDir, { recursive: true });
@@ -1340,9 +1599,12 @@ export const proxyInstallCommand = {
         if (!existsSync(PLIST_DIR)) {
             mkdirSync(PLIST_DIR, { recursive: true });
         }
-        const plist = buildPlist(port, host);
+        const plist = buildPlist(port, host, envFile, configFile);
         writeFileSync(PLIST_PATH, plist, "utf-8");
         console.info(chalk.green(`✓ Plist written to ${PLIST_PATH}`));
+        if (envFile) {
+            console.info(chalk.green(`✓ Proxy env file: ${envFile}`));
+        }
         try {
             const { execFileSync } = await import("node:child_process");
             execFileSync("launchctl", ["unload", PLIST_PATH], {
@@ -1375,6 +1637,7 @@ export const proxyInstallCommand = {
                     host,
                     strategy: "fill-first",
                     startTime: new Date().toISOString(),
+                    envFile,
                     managedBy: "launchd",
                 });
             }

package/dist/cli/commands/task.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Task CLI Commands for NeuroLink
+ *
+ * Implements commands for task scheduling and management:
+ * - neurolink task create   — Create a scheduled task (pure store write, exits immediately)
+ * - neurolink task list     — List all tasks
+ * - neurolink task get      — Show task details
+ * - neurolink task run      — Run a task immediately
+ * - neurolink task pause    — Pause a task
+ * - neurolink task resume   — Resume a paused task
+ * - neurolink task update   — Update a task
+ * - neurolink task delete   — Delete a task
+ * - neurolink task logs     — View run history
+ * - neurolink task start    — Start worker (keeps process alive for scheduled tasks)
+ * - neurolink task stop     — Stop a running daemon worker
+ * - neurolink task status   — Show worker status
+ */
+import type { CommandModule } from "yargs";
+export declare class TaskCommandFactory {
+    static createTaskCommands(): CommandModule;
+    /**
+     * Get a full NeuroLink instance (with MCP, tools, providers).
+     * Used only by commands that execute AI: run, start/_worker.
+     */
+    private static getNeuroLink;
+    /**
+     * Get a direct TaskStore instance for pure store operations.
+     * Bypasses NeuroLink entirely — no MCP, no providers, no tools.
+     * Respects the same backend selection as TaskManager so both paths
+     * read/write the same store (Redis for bullmq, file for node-timeout).
+     *
+     * Used by all management commands: create, list, get, delete, logs, pause, resume, update.
+     */
+    private static getStore;
+    /** Attach event listeners and keep the process alive for scheduled task execution */
+    private static enterWorkerMode;
+    /**
+     * Create — pure store write, no NeuroLink needed.
+     * Builds the Task object directly, saves to the task store, exits immediately.
+     */
+    private static executeCreate;
+    private static executeList;
+    private static executeGet;
+    private static executeRun;
+    private static executePause;
+    private static executeResume;
+    private static executeUpdate;
+    private static executeDelete;
+    private static executeLogs;
+    private static executeStart;
+    private static executeStop;
+    private static executeStatus;
+    private static spawnDaemon;
+    private static runForegroundWorker;
+    private static executeWorkerProcess;
+}