target-supabase-sdk 0.1.9 → 0.2.1

package/dist/node.js

@@ -0,0 +1,2483 @@
+import { z } from 'zod';
+import { M as MAX_POLL_TARGET_LIST_SIZE, E as validateWithSchema, d as createLogger, u as pollTargetList, g as generateResponse, e as createTarget, z as supabase, s as logManager, G as createScope, L as LogLevel, H as patchScope, y as scanTargetList, h as getPossibleTarget, p as isOptimisticLockResponse, I as withModule, A as updateTargetDetails } from './chunks/create-logger-DyH3mZ8p.js';
+export { B as BaseValidator, C as CREATE_TARGET_ALREADY_EXISTS_MESSAGE, a as CategoryList, b as MAX_TARGET_LIST_PAGE_SIZE, O as OPTIMISTIC_LOCK_ERROR_CODE, c as OPTIMISTIC_LOCK_FAILED_MESSAGE, P as PostListValidator, S as StatusCode, f as deleteTarget, i as getTarget, j as getTargetList, k as getTargetTotalCount, l as handleSupabaseError, m as isCreateTargetAlreadyExistsError, n as isDevEnvironment, o as isOptimisticLockError, q as logDev, r as logDevGroup, t as patchTarget, v as postListCreate, w as postLogListCreate, x as postTarget, D as validateWith } from './chunks/create-logger-DyH3mZ8p.js';
+import { l as loadEnvFiles, b as readEnv, c as requireEnv } from './chunks/enable-log-persist-C_bSw6Kx.js';
+export { d as createJsonFileStateStore, e as disableLogPersist, f as enableLogPersist, g as ensureLogPersistFromEnv, h as envBool, i as envInt, j as envMs, k as envNumber, m as envPort, n as getLogPersistStats, a as logPersistEnabledFromEnv, p as parseEnvFile, o as parseEnvLine, q as pollUntil, s as resolveLogPersistRegistryPath, r as resolveProjectRootByPackageName, t as resolveProjectRootFromModule, u as snapshotLogPersistReady, v as validateLogPersistPreloadEnv, w as waitForLogPersistReady } from './chunks/enable-log-persist-C_bSw6Kx.js';
+import { access, stat, readFile, mkdir, writeFile, readdir } from 'node:fs/promises';
+import { resolve, join, isAbsolute, dirname } from 'node:path';
+import { aq as sha256Hex, as as getErrorMessage, a9 as postRegisterNode, U as patchChangeNodeStatus, N as NodeStatus, a0 as patchStopNode, _ as patchNodeHeartBeat, d as CategoryRepo, R as ResultCode, at as LOG_TOPIC_TASK, T as TASK_REPO_USAGE, D as getScanRemoteRepoValues, Y as patchClaimTask, au as CRITICAL_UNKNOWN_TASK_TRACE_ID, W as patchChangeTaskStatus, j as TaskStatusAction, av as toError, ae as postTaskSchema, aw as createTaskRow, i as TaskStatus } from './chunks/word.interface-DLgRobKV.js';
+export { A as ApiMethod, C as CategoryIdea, a as CategoryLink, b as CategoryNode, c as CategoryParcel, e as CategoryService, f as CategoryTask, g as CategoryWord, M as Market, P as ParcelManager, h as PostLinkValidator, S as ServiceLifecycleStatus, k as apiDetailsSchema, l as classifyNetworkError, m as countTasksByType, n as createStorageProviderRegistry, o as createUploadTracker, p as deleteParcel, q as deleteParcelSchema, r as discoverService, s as evaluateBusyNodeLiveness, t as fetchBinaryWithRetry, u as fetchWithRetry, v as fieldDefinitionSchema, w as formatNetworkError, x as getApi, y as getApiSchema, z as getParcel, B as getParcelSchema, E as getScanRemoteRepoValuesSchema, F as getService, G as getServiceSchema, H as installChunkFetchRegistry, I as isHttpUrl, J as isLocalFilesystemPath, K as isOpaqueChunkUrl, L as isRetryableHttpStatus, O as parcelDetailsSchema, Q as parseProviderPrefixedUrl, V as patchChangeNodeStatusSchema, X as patchChangeTaskStatusSchema, Z as patchClaimTaskSchema, $ as patchNodeHeartBeatSchema, a1 as patchStopNodeSchema, a2 as patchTaskProgress, a3 as patchTaskProgressSchema, a4 as postApi, a5 as postApiSchema, a6 as postLinkCreate, a7 as postParcel, a8 as postParcelSchema, aa as postRegisterNodeSchema, ab as postService, ac as postServiceSchema, ad as postTask, af as publishParcel, ag as registerProviderChunkResolver, ah as requestHasBody, ai as resolveFetchUrl, aj as restoreParcel, ak as restoreParcelById, al as sanitizeFileName, am as sanitizeParcelFileName, an as schemaDefinitionSchema, ao as serviceDetailsSchema, ap as serviceLifecycleSchema, ar as summarizeTaskQueue } from './chunks/word.interface-DLgRobKV.js';
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { tmpdir } from 'node:os';
+import { pathToFileURL } from 'node:url';
+import '@supabase/supabase-js';
+import 'lodash-es';
+import 'node:fs';
+
+var CategoryCommand;
+(function (CategoryCommand) {
+    CategoryCommand["COMMAND"] = "command";
+})(CategoryCommand || (CategoryCommand = {}));
+var CommandType;
+(function (CommandType) {
+    CommandType["STOP_NODE"] = "stop-node";
+})(CommandType || (CommandType = {}));
+
+const nodeIdSchema = z.string().trim().min(1);
+const traceIdSchema$1 = z.string().trim().min(1).optional();
+// ─── Zod schemas ─────────────────────────────────────────────────────────────
+const postCommandSchema = z.object({
+    nodeId: nodeIdSchema,
+    command: z.nativeEnum(CommandType),
+    traceId: traceIdSchema$1,
+});
+const getPollCommandListSchema = z.object({
+    nodeId: nodeIdSchema,
+    size: z.number().int().min(1).max(MAX_POLL_TARGET_LIST_SIZE).optional(),
+    traceId: traceIdSchema$1,
+});
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function commandNodeFilter(nodeId) {
+    return [{ field: "value", operator: "eq", value: nodeId }];
+}
+// ─── postCommand ─────────────────────────────────────────────────────────────
+/** Enqueue a control command for `nodeId` (scheduler / admin). */
+const postCommand = validateWithSchema(postCommandSchema, "postCommandSchema")(async ({ nodeId, command, traceId }) => {
+    const logger = createLogger({ module: "postCommand", traceId, labels: { nodeId } });
+    const result = await createTarget({
+        payload: { nodeId, command, traceId },
+        createFn: () => ({
+            name: command,
+            value: nodeId,
+            category: CategoryCommand.COMMAND,
+            tagList: [],
+        }),
+    });
+    logger.info("Command已入隊", {
+        topic: "command",
+        data: { nodeId, command },
+    });
+    return result;
+});
+// ─── getPollCommandList ──────────────────────────────────────────────────────
+/** Dequeue control commands for `nodeId` (oldest first). */
+const getPollCommandList = validateWithSchema(getPollCommandListSchema, "getPollCommandListSchema")(async ({ nodeId, size, traceId }) => {
+    const logger = createLogger({ module: "getPollCommandList", traceId, labels: { nodeId } });
+    const { data: dequeuedList = [] } = await pollTargetList({
+        category: CategoryCommand.COMMAND,
+        size: size ?? 50,
+        filterList: commandNodeFilter(nodeId),
+        ascending: true,
+    });
+    if (dequeuedList.length === 0) {
+        logger.debug("Command", {
+            topic: "command",
+            data: { nodeId, dequeued: dequeuedList.length },
+        });
+    }
+    else {
+        logger.info("Command", {
+            topic: "command",
+            data: { nodeId, dequeued: dequeuedList.length },
+        });
+    }
+    return generateResponse.success(dequeuedList);
+});
+
+/**
+ * Load standard Supabase env vars and initialize the process-wide Supabase holder.
+ *
+ * Required: `SUPABASE_URL`, `SUPABASE_ANON_KEY`
+ * Optional: `SUPABASE_NEED_AUTH_URL`, `SUPABASE_NEED_AUTH_ANON_KEY`
+ */
+async function initSupabaseFromStandardEnv(options = {}) {
+    const env = options.env ?? process.env;
+    const loadEnv = options.loadEnv ?? true;
+    if (loadEnv) {
+        if (options.root == null || options.root === "") {
+            throw new Error("initSupabaseFromStandardEnv: root is required when loadEnv is true");
+        }
+        loadEnvFiles(options.root, { env, afterLoad: options.afterLoadEnv });
+    }
+    await supabase.initialize({
+        supabaseUrl: requireEnv("SUPABASE_URL", env),
+        supabaseAnonKey: requireEnv("SUPABASE_ANON_KEY", env),
+        supabaseNeedAuthUrl: readEnv("SUPABASE_NEED_AUTH_URL", env),
+        supabaseNeedAuthAnonKey: readEnv("SUPABASE_NEED_AUTH_ANON_KEY", env),
+    });
+}
+
+/**
+ * Public base URL: `envKey` if set (trailing slash stripped), else `http://localhost:{port}`.
+ */
+function publicBaseUrlFromEnv(port, options) {
+    const configured = readEnv(options.envKey, options.env ?? process.env);
+    if (configured != null) {
+        return configured.replace(/\/$/, "");
+    }
+    return `http://localhost:${port}`;
+}
+
+/** Copy a Node.js Buffer view to a standalone ArrayBuffer. */
+function nodeBufferToArrayBuffer(nodeBuffer) {
+    return nodeBuffer.buffer.slice(nodeBuffer.byteOffset, nodeBuffer.byteOffset + nodeBuffer.byteLength);
+}
+/** Read a local file with basic validation and SHA-256 digest. */
+async function readAndVerifySourceFile(filePath, options = {}) {
+    const absolutePath = resolve(filePath);
+    const allowEmpty = options.allowEmpty === true;
+    try {
+        await access(absolutePath);
+    }
+    catch {
+        throw new Error(`Source file not found: ${absolutePath}`);
+    }
+    const fileStat = await stat(absolutePath);
+    if (!fileStat.isFile()) {
+        throw new Error(`Source path is not a file: ${absolutePath}`);
+    }
+    if (!allowEmpty && fileStat.size <= 0) {
+        throw new Error(`Source file is empty: ${absolutePath}`);
+    }
+    if (options.maxBytes != null && fileStat.size > options.maxBytes) {
+        throw new Error(`Source file exceeds maxBytes (${fileStat.size} > ${options.maxBytes}): ${absolutePath}`);
+    }
+    const nodeBuffer = await readFile(absolutePath);
+    const buffer = nodeBufferToArrayBuffer(nodeBuffer);
+    if (buffer.byteLength !== fileStat.size) {
+        throw new Error(`Source file size mismatch after read (${buffer.byteLength} !== ${fileStat.size}): ${absolutePath}`);
+    }
+    const digest = await sha256Hex(buffer);
+    if (options.expectedSha256 != null && digest.toLowerCase() !== options.expectedSha256.toLowerCase()) {
+        throw new Error(`Source file SHA-256 mismatch (expected ${options.expectedSha256}, got ${digest}): ${absolutePath}`);
+    }
+    return {
+        absolutePath,
+        buffer,
+        size: buffer.byteLength,
+        sha256: digest,
+    };
+}
+
+const formatTimestamp = (timestamp) => {
+    return new Intl.DateTimeFormat("zh-CN", {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hour12: false,
+        fractionalSecondDigits: 3,
+    }).format(timestamp);
+};
+const formatRelativeTime = (timestamp) => {
+    const now = Date.now();
+    const diff = now - timestamp;
+    if (diff < 1000)
+        return "刚刚";
+    if (diff < 60000)
+        return `${Math.floor(diff / 1000)}秒前`;
+    if (diff < 3600000)
+        return `${Math.floor(diff / 60000)}分钟前`;
+    if (diff < 86400000)
+        return `${Math.floor(diff / 3600000)}小时前`;
+    return formatTimestamp(timestamp);
+};
+const getRandomInterval = () => {
+    const min = 15 * 1000;
+    const max = 1 * 60 * 1000;
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+const formatHeartbeat = (timestamp) => {
+    const absolute = formatTimestamp(timestamp);
+    const relative = formatRelativeTime(timestamp);
+    return `${absolute} (${relative})`;
+};
+
+const LOG_TOPIC_NODE = "node";
+const LOG_TOPIC_COMMAND = "command";
+const LOG_TOPIC_PROCESS = "process";
+/**
+ * Shared node process runtime: bootstrap, main-loop frame, heartbeat, commands, shutdown.
+ * Subclasses implement {@link onBeforeRegisterNode} and {@link runLoopSteps}.
+ */
+class BaseNodeRuntime {
+    static HEARTBEAT_FAILURE_THRESHOLD = 3;
+    /** Log `nodeId` label while startup has not yet received an assigned id from Supabase. */
+    static NODE_ID_PENDING_ASSIGNMENT = "pending-node-id";
+    runtimeModule;
+    _localNodeId = null;
+    _isNodeIdLocked = false;
+    isRunning;
+    loopCount;
+    consecutiveHeartbeatFailures = 0;
+    startupTraceId;
+    startupScope;
+    shutdownPromise = null;
+    startPromise = null;
+    get localNodeId() {
+        return this._localNodeId;
+    }
+    set localNodeId(value) {
+        if (this._isNodeIdLocked) {
+            throw new Error("Node ID cannot be modified after initial assignment");
+        }
+        if (typeof value !== "string" || value.trim() === "") {
+            throw new Error("Invalid node ID");
+        }
+        this._localNodeId = value;
+        this._isNodeIdLocked = true;
+    }
+    constructor(runtimeModule) {
+        this.runtimeModule = runtimeModule;
+        this.isRunning = false;
+        this.loopCount = 0;
+        this.startupTraceId = logManager.generateTraceId();
+        this.startupScope = createScope({ module: runtimeModule, traceId: this.startupTraceId });
+    }
+    /** Hook: minimum log level for main-loop scoped loggers (heartbeat, batchCommand, iteration). */
+    loopLoggerMinLevel() {
+        return LogLevel.INFO;
+    }
+    /** Hook: ms to wait between loop iterations. Default: random 15–60s. */
+    getLoopIntervalMs() {
+        return getRandomInterval();
+    }
+    getLogNodeId() {
+        return this.localNodeId ?? BaseNodeRuntime.NODE_ID_PENDING_ASSIGNMENT;
+    }
+    isShuttingDown() {
+        return this.shutdownPromise != null;
+    }
+    requestShutdown(trigger) {
+        void this.shutdown({ trigger });
+    }
+    registerProcessLifecycle(logger) {
+        process.on("SIGTERM", () => {
+            logger.warn("收到 SIGTERM 信號，準備關閉節點", { topic: LOG_TOPIC_PROCESS });
+            this.requestShutdown("SIGTERM");
+        });
+        process.on("SIGINT", () => {
+            logger.warn("收到 SIGINT 信號，準備關閉節點", { topic: LOG_TOPIC_PROCESS });
+            this.requestShutdown("SIGINT");
+        });
+        process.on("uncaughtException", (error) => {
+            if (this.shutdownPromise != null) {
+                logger.critical("shutdown 進行中發生未捕獲異常，立即關閉節點", {
+                    topic: LOG_TOPIC_PROCESS,
+                    data: {
+                        name: error.name,
+                        message: error.message,
+                        stack: error.stack,
+                    },
+                });
+                process.exit(1);
+                return;
+            }
+            logger.critical("未捕獲的異常，準備關閉節點", {
+                topic: LOG_TOPIC_PROCESS,
+                data: {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                },
+            });
+            this.requestShutdown("uncaughtException");
+        });
+        process.on("unhandledRejection", (reason) => {
+            if (this.shutdownPromise != null) {
+                logger.error("shutdown 進行中發生未處理的 Promise 拒絕", {
+                    topic: LOG_TOPIC_PROCESS,
+                    data: {
+                        reason: getErrorMessage(reason),
+                        stack: reason instanceof Error ? reason.stack : undefined,
+                    },
+                });
+                return;
+            }
+            logger.error("未處理的 Promise 拒絕，準備關閉節點", {
+                topic: LOG_TOPIC_PROCESS,
+                data: {
+                    reason: getErrorMessage(reason),
+                    stack: reason instanceof Error ? reason.stack : undefined,
+                },
+            });
+            this.requestShutdown("unhandledRejection");
+        });
+    }
+    async start() {
+        if (this.startPromise != null) {
+            return this.startPromise;
+        }
+        this.startPromise = this.runStart();
+        return this.startPromise;
+    }
+    async runStart() {
+        const logger = createLogger({
+            scope: patchScope({ scope: this.startupScope, patch: { labels: { nodeId: this.getLogNodeId() } } }),
+        });
+        logger.debug("節點進程啟動中", {
+            topic: LOG_TOPIC_NODE,
+            data: {
+                pid: process.pid,
+                env: process.env.NODE_ENV ?? "development",
+                runtime: this.runtimeModule,
+            },
+        });
+        this.registerProcessLifecycle(logger);
+        try {
+            await this.onBeforeRegisterNode(logger);
+        }
+        catch (error) {
+            logger.error("節點啟動前置步驟失敗", {
+                topic: LOG_TOPIC_NODE,
+                data: { error: getErrorMessage(error) },
+            });
+            this.requestShutdown("bootstrap:pre-register");
+            return;
+        }
+        logger.debug("開始向 Supabase 註冊節點", { topic: LOG_TOPIC_NODE });
+        try {
+            const { data, error } = await postRegisterNode({ traceId: this.startupTraceId });
+            if (data == null || error) {
+                throw error ?? new Error("postRegisterNode 失敗");
+            }
+            this.localNodeId = data.id;
+            logger.resetScope({ labels: { nodeId: data.id } });
+            logger.success("節點註冊成功", {
+                topic: LOG_TOPIC_NODE,
+                data: {
+                    nodeId: data.id,
+                    details: data.details,
+                },
+            });
+        }
+        catch (error) {
+            logger.error("節點註冊失敗", {
+                topic: LOG_TOPIC_NODE,
+                data: { error: getErrorMessage(error) },
+            });
+            this.requestShutdown("bootstrap:register-node");
+            return;
+        }
+        const nodeId = this.localNodeId;
+        logger.debug("節點準備進入主循環", { topic: LOG_TOPIC_NODE });
+        const { error: enterBusyError } = await patchChangeNodeStatus({
+            nodeId,
+            status: NodeStatus.BUSY,
+            fromStatus: NodeStatus.READY,
+            traceId: this.startupTraceId,
+        });
+        if (enterBusyError) {
+            logger.error("節點進入主循環失敗，無法更新節點狀態為 BUSY", {
+                topic: LOG_TOPIC_NODE,
+                data: { error: enterBusyError.message },
+            });
+            this.requestShutdown("bootstrap:enter-busy");
+            return;
+        }
+        logger.debug("節點狀態已設為 BUSY 進入主循環", { topic: LOG_TOPIC_NODE, data: { nodeId } });
+        await this.runLoop(nodeId);
+    }
+    async runLoop(nodeId) {
+        this.isRunning = true;
+        while (this.isRunning) {
+            this.loopCount++;
+            const loopTraceId = logManager.generateTraceId();
+            const loopScope = createScope({
+                module: `${this.runtimeModule}-loop-iteration`,
+                traceId: loopTraceId,
+                labels: { nodeId },
+            });
+            const loopCtx = { loopTraceId, nodeId };
+            const iterLogger = createLogger({
+                scope: loopScope,
+                minLevel: this.loopLoggerMinLevel(),
+            });
+            iterLogger.debug(`主循環第 ${this.loopCount} 輪開始`, {
+                topic: LOG_TOPIC_NODE,
+                data: { nodeId, loopCount: this.loopCount },
+            });
+            try {
+                await this.batchCommand(loopCtx);
+                if (this.isShuttingDown()) {
+                    iterLogger.debug("節點關閉中，跳過本輪剩餘步驟", { topic: LOG_TOPIC_NODE });
+                    break;
+                }
+                const heartbeatOk = await this.heartbeat(loopCtx);
+                if (this.isShuttingDown()) {
+                    iterLogger.debug("節點關閉中，跳過本輪剩餘步驟", { topic: LOG_TOPIC_NODE });
+                    break;
+                }
+                await this.runLoopSteps(loopCtx, heartbeatOk);
+            }
+            catch (error) {
+                iterLogger.critical(`主循環第 ${this.loopCount} 輪遇到未知錯誤`, {
+                    topic: LOG_TOPIC_NODE,
+                    data: { error: getErrorMessage(error) },
+                });
+            }
+            if (this.isShuttingDown()) {
+                iterLogger.debug("節點關閉中，跳過等待間隔", { topic: LOG_TOPIC_NODE });
+                break;
+            }
+            const interval = this.getLoopIntervalMs();
+            iterLogger.debug(`主循環第 ${this.loopCount} 輪完成，等待下一輪`, {
+                topic: LOG_TOPIC_NODE,
+                data: { intervalMs: interval },
+            });
+            await new Promise((resolve) => setTimeout(resolve, interval));
+        }
+    }
+    async shutdown(options) {
+        if (this.shutdownPromise != null) {
+            const logger = createLogger({
+                scope: patchScope({ scope: this.startupScope, patch: { labels: { nodeId: this.getLogNodeId() } } }),
+            });
+            logger.debug("shutdown 已在進行，跳過重複調用", {
+                topic: LOG_TOPIC_NODE,
+                data: { trigger: options?.trigger ?? "unknown" },
+            });
+            return this.shutdownPromise;
+        }
+        this.isRunning = false;
+        this.shutdownPromise = this.runShutdown(options?.trigger).catch((error) => {
+            const logger = createLogger({
+                scope: patchScope({ scope: this.startupScope, patch: { labels: { nodeId: this.getLogNodeId() } } }),
+            });
+            logger.error("shutdown 流程異常", {
+                topic: LOG_TOPIC_NODE,
+                data: {
+                    trigger: options?.trigger ?? "explicit",
+                    error: getErrorMessage(error),
+                },
+            });
+            process.exit(1);
+        });
+        return this.shutdownPromise;
+    }
+    async runShutdown(trigger) {
+        const logger = createLogger({
+            scope: patchScope({ scope: this.startupScope, patch: { labels: { nodeId: this.getLogNodeId() } } }),
+        });
+        logger.debug("正在關閉節點進程", {
+            topic: LOG_TOPIC_NODE,
+            data: { trigger: trigger ?? "explicit" },
+        });
+        if (this.localNodeId == null) {
+            logger.warn("本地節點未註冊，進程退出", { topic: LOG_TOPIC_NODE });
+            process.exit(0);
+            return;
+        }
+        logger.debug("正在登出節點", { topic: LOG_TOPIC_NODE, data: { nodeId: this.localNodeId } });
+        try {
+            const { error } = await patchStopNode({
+                nodeId: this.localNodeId,
+                traceId: this.startupTraceId,
+            });
+            if (error) {
+                throw new Error(`patchStopNode 失敗: ${error.message}`);
+            }
+            logger.success("節點正常關閉，進程退出", { topic: LOG_TOPIC_NODE });
+        }
+        catch (error) {
+            logger.critical("登出節點失敗，進程退出", {
+                topic: LOG_TOPIC_NODE,
+                data: { error: getErrorMessage(error) },
+            });
+        }
+        finally {
+            process.exit(0);
+        }
+    }
+    async heartbeat(ctx) {
+        const { loopTraceId, nodeId } = ctx;
+        const logger = createLogger({
+            scope: createScope({
+                module: "heartbeat",
+                traceId: loopTraceId,
+                labels: { nodeId },
+            }),
+            minLevel: this.loopLoggerMinLevel(),
+        });
+        logger.debug("開始發送心跳", { topic: LOG_TOPIC_NODE });
+        let error;
+        let lastHeartBeat;
+        try {
+            const response = await patchNodeHeartBeat({ nodeId, traceId: loopTraceId });
+            error = response.error;
+            lastHeartBeat = response.data;
+        }
+        catch (caught) {
+            error = { message: getErrorMessage(caught) };
+            lastHeartBeat = null;
+        }
+        if (error || lastHeartBeat == null) {
+            this.consecutiveHeartbeatFailures++;
+            const failureCount = this.consecutiveHeartbeatFailures;
+            const logData = {
+                error: getErrorMessage(error),
+                consecutiveFailures: failureCount,
+                threshold: BaseNodeRuntime.HEARTBEAT_FAILURE_THRESHOLD,
+            };
+            if (failureCount >= BaseNodeRuntime.HEARTBEAT_FAILURE_THRESHOLD) {
+                logger.critical("連續心跳失敗達上限，準備關閉節點", {
+                    topic: LOG_TOPIC_NODE,
+                    data: logData,
+                });
+                this.requestShutdown("heartbeat:consecutive-failures");
+            }
+            else {
+                logger.warn("心跳更新失敗", { topic: LOG_TOPIC_NODE, data: logData });
+            }
+            return false;
+        }
+        this.consecutiveHeartbeatFailures = 0;
+        logger.success("心跳更新成功", {
+            topic: LOG_TOPIC_NODE,
+            data: { lastHeartBeat: formatHeartbeat(lastHeartBeat) },
+        });
+        return true;
+    }
+    async batchCommand(ctx) {
+        const { loopTraceId, nodeId } = ctx;
+        const cmdLogger = createLogger({
+            scope: createScope({
+                module: "batchCommand",
+                traceId: loopTraceId,
+                labels: { nodeId },
+            }),
+            minLevel: this.loopLoggerMinLevel(),
+        });
+        cmdLogger.debug("開始檢查控制指令", { topic: LOG_TOPIC_COMMAND });
+        const { data: commandList = [], error: pollError } = await getPollCommandList({
+            nodeId,
+            traceId: loopTraceId,
+            size: MAX_POLL_TARGET_LIST_SIZE,
+        });
+        if (pollError) {
+            cmdLogger.warn("獲取指令失敗", {
+                topic: LOG_TOPIC_COMMAND,
+                data: { error: pollError.message },
+            });
+            return;
+        }
+        if (commandList.length === 0) {
+            cmdLogger.debug("獲取指令數量為0 無需執行", { topic: LOG_TOPIC_COMMAND });
+            return;
+        }
+        cmdLogger.debug(`獲取到控制指令數量為${commandList.length}`, {
+            topic: LOG_TOPIC_COMMAND,
+            data: { count: commandList.length, commandList: commandList.map((command) => command.name) },
+        });
+        for (const command of commandList) {
+            const cmd = command.name;
+            cmdLogger.info("執行控制指令", {
+                topic: LOG_TOPIC_COMMAND,
+                data: { commandId: command.id, cmd },
+            });
+            try {
+                await this.executeCommand(cmd, ctx);
+                cmdLogger.success("控制指令執行成功", {
+                    topic: LOG_TOPIC_COMMAND,
+                    data: { commandId: command.id, cmd },
+                });
+            }
+            catch (error) {
+                cmdLogger.warn("控制指令執行失敗", {
+                    topic: LOG_TOPIC_COMMAND,
+                    data: {
+                        commandId: command.id,
+                        cmd,
+                        error: getErrorMessage(error),
+                    },
+                });
+            }
+        }
+        cmdLogger.debug("控制指令批次處理完成", {
+            topic: LOG_TOPIC_COMMAND,
+        });
+    }
+    /** Shared commands, then {@link resolveNodeCommand} for subclass-specific handling. */
+    async executeCommand(cmd, ctx) {
+        if (cmd === CommandType.STOP_NODE) {
+            this.requestShutdown("cmd:STOP_NODE");
+            return;
+        }
+        await this.resolveNodeCommand(cmd, ctx);
+    }
+    /**
+     * Hook: handle node-type-specific {@link CommandType} values.
+     * Default rejects anything not handled in {@link executeCommand}.
+     */
+    async resolveNodeCommand(cmd, _ctx) {
+        throw new Error(`無法解析的 cmd: ${cmd}`);
+    }
+}
+
+/**
+ * Build argv for `node --import … --import tsx <entry>`.
+ * Use **relative** preload paths with `cwd: projectRoot` — Node 24 on Windows rejects
+ * absolute paths like `D:\…` for `--import` (ESM URL scheme error).
+ */
+function buildNodeImportArgs(input) {
+    const preloadModules = input.preloadModules ?? [];
+    const useTsx = input.useTsx ?? true;
+    const args = [];
+    for (const modulePath of preloadModules) {
+        args.push("--import", modulePath);
+    }
+    if (useTsx) {
+        args.push("--import", "tsx");
+    }
+    args.push(input.entryScript);
+    return args;
+}
+/** Spawn `node` with preload chain + tsx + TypeScript entry (relative to projectRoot). */
+function spawnTsxChild(options) {
+    return spawn(process.execPath, buildNodeImportArgs({
+        preloadModules: options.preloadModules,
+        useTsx: options.useTsx,
+        entryScript: options.entryScript,
+    }), {
+        cwd: options.projectRoot,
+        env: options.env ?? process.env,
+        stdio: options.stdio ?? "inherit",
+        shell: false,
+    });
+}
+function isChildProcessRunning(child) {
+    return child != null && child.exitCode == null && !child.killed;
+}
+
+/**
+ * Process-local registry for tsx child processes (supervisor, worker, etc.).
+ * Each OS process has its own instance - do not expect cross-process PID tracking.
+ */
+class ManagedChildProcesses {
+    projectRoot;
+    preloadModules;
+    graceMs;
+    logger;
+    byLabel = new Map();
+    constructor(options) {
+        this.projectRoot = options.projectRoot;
+        this.preloadModules = options.preloadModules ?? [];
+        this.graceMs = options.graceMs ?? 5_000;
+        this.logger = options.logger;
+    }
+    get(label) {
+        return this.byLabel.get(label) ?? null;
+    }
+    getRunning(label) {
+        const child = this.byLabel.get(label);
+        return isChildProcessRunning(child) ? child : null;
+    }
+    runningLabels() {
+        return [...this.byLabel.entries()]
+            .filter((entry) => isChildProcessRunning(entry[1]))
+            .map(([label]) => label);
+    }
+    spawn(label, entryScript) {
+        const existing = this.getRunning(label);
+        if (existing != null) {
+            return { child: existing, created: false };
+        }
+        const child = spawnTsxChild({
+            projectRoot: this.projectRoot,
+            entryScript,
+            preloadModules: this.preloadModules,
+        });
+        child.on("exit", (code, signal) => {
+            this.logger?.info("child exited", { topic: "process", data: { label, code, signal } });
+            const current = this.byLabel.get(label);
+            if (current === child) {
+                this.byLabel.delete(label);
+            }
+        });
+        this.byLabel.set(label, child);
+        this.logger?.info("child started", {
+            topic: "process",
+            data: {
+                label,
+                pid: child.pid,
+                script: resolve(this.projectRoot, entryScript),
+            },
+        });
+        return { child, created: true };
+    }
+    async stopAll(options) {
+        const tracked = [...this.byLabel.values()].filter((child) => isChildProcessRunning(child));
+        await Promise.all(tracked.map((child) => this.stopChild(child)));
+        const extraPids = options?.extraPids ?? [];
+        for (const pid of extraPids) {
+            if (pid == null || tracked.some((child) => child.pid === pid)) {
+                continue;
+            }
+            try {
+                process.kill(pid, "SIGTERM");
+            }
+            catch {
+                // already exited
+            }
+        }
+    }
+    stopChild(child) {
+        return new Promise((resolvePromise) => {
+            child.once("exit", () => resolvePromise());
+            child.kill("SIGTERM");
+            setTimeout(() => {
+                if (isChildProcessRunning(child)) {
+                    child.kill("SIGKILL");
+                }
+            }, this.graceMs);
+        });
+    }
+}
+
+/** Factory: all listed env keys must be non-empty. */
+function createRequiredEnvCheck(name, keys, options) {
+    return () => {
+        const env = options?.env ?? process.env;
+        try {
+            for (const key of keys) {
+                requireEnv(key, env);
+            }
+            return { name, ok: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { name, ok: false, detail: message };
+        }
+    };
+}
+/** Factory: every path must exist on disk. */
+function createPathsExistCheck(name, paths, options) {
+    return async () => {
+        for (const filePath of paths) {
+            try {
+                await access(filePath);
+            }
+            catch {
+                return {
+                    name,
+                    ok: false,
+                    detail: options?.missingDetail ?? `Missing ${filePath}`,
+                };
+            }
+        }
+        const detail = options?.successDetail ?? paths[paths.length - 1] ?? paths.join(", ");
+        return { name, ok: true, detail };
+    };
+}
+/** Factory: lightweight Supabase query via {@link scanTargetList}. */
+function createSupabaseReachableCheck(options) {
+    const name = options?.name ?? "supabase_connectivity";
+    const category = options?.category ?? "node";
+    const maxRows = options?.maxRows ?? 1;
+    return async () => {
+        try {
+            await scanTargetList({ category, maxRows });
+            return { name, ok: true };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { name, ok: false, detail: message };
+        }
+    };
+}
+
+function formatFailureMessage(checks) {
+    return checks
+        .filter((check) => !check.ok)
+        .map((check) => `${check.name}: ${check.detail ?? "failed"}`)
+        .join("; ");
+}
+/** Run checks in order and aggregate into a {@link ReadinessReport}. */
+async function runReadinessChecks(checks) {
+    const results = await Promise.all(checks.map((check) => check()));
+    const failed = results.filter((check) => !check.ok);
+    return {
+        ok: failed.length === 0,
+        checks: results,
+        message: failed.length === 0 ? null : formatFailureMessage(results),
+    };
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Poll {@link ServiceReadyGate} until ready, fail fast on `failed`, or timeout.
+ * Returns the final ready snapshot.
+ */
+async function waitForServiceReady(gate, options) {
+    const pollMs = options.pollMs ?? 500;
+    const defaultFailureMessage = options.failureMessage ?? "Readiness checks failed";
+    const deadline = Date.now() + options.timeoutMs;
+    let last = { failed: false, ready: false };
+    while (Date.now() < deadline) {
+        last = await gate.read();
+        if (last.failed) {
+            throw new Error(last.failureMessage ?? defaultFailureMessage);
+        }
+        if (last.ready) {
+            options.logger?.info("service ready", {
+                topic: "readiness",
+                data: last.readyDetail ?? {},
+            });
+            return last;
+        }
+        await sleep(pollMs);
+    }
+    const message = options.formatTimeoutError?.(last, options.timeoutMs) ??
+        `Service ready timeout after ${options.timeoutMs}ms (failed=${last.failed}, ready=${last.ready})`;
+    throw new Error(message);
+}
+
+/** Supabase `target.category` for rows that store task script payloads */
+const TASK_REPO_SCRIPT_CATEGORY = "script";
+/** Host app config directory (relative to `cwd`) — recommended for library consumers */
+const TASK_RUNNER_CONFIG_DIR = "config";
+const TASK_RUNNER_ROOT_CONFIG_FILENAME = "task.config.js";
+/** Default root config path: `config/task.config.js` */
+const TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH = `${TASK_RUNNER_CONFIG_DIR}/${TASK_RUNNER_ROOT_CONFIG_FILENAME}`;
+/** Legacy fallback at project root */
+const TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH = TASK_RUNNER_ROOT_CONFIG_FILENAME;
+/** Per-task config filename inside each folder under `taskDir` */
+const TASK_LOCAL_PACKAGE_CONFIG_FILENAME = "task.config.js";
+
+/**
+ * Directory containing a config file — anchor for paths declared **inside** that file.
+ */
+function getConfigFileDir(configFilePath) {
+    return dirname(configFilePath);
+}
+/**
+ * Resolve a path from a config file's directory.
+ *
+ * - Absolute `pathInConfig` → returned as-is
+ * - Relative `pathInConfig` → `resolve(dirname(configFilePath), pathInConfig)`
+ *
+ * **Not** relative to `process.cwd()`. See `.cursor/skills/config-file-relative-paths/SKILL.md`.
+ */
+function resolvePathFromConfigFile(configFilePath, pathInConfig) {
+    const trimmed = pathInConfig.trim();
+    if (isAbsolute(trimmed)) {
+        return trimmed;
+    }
+    return resolve(getConfigFileDir(configFilePath), trimmed);
+}
+/**
+ * Resolve a path from an explicit base directory (e.g. task package dir for `entry`).
+ * Same rules as {@link resolvePathFromConfigFile}, but base is already known.
+ */
+function resolvePathFromBaseDir(baseDir, path) {
+    const trimmed = path.trim();
+    if (isAbsolute(trimmed)) {
+        return trimmed;
+    }
+    return resolve(baseDir, trimmed);
+}
+/**
+ * Resolve a path from `cwd` — for **discovering** config files, not for fields inside them.
+ */
+function resolvePathFromCwd(cwd, path) {
+    const trimmed = path.trim();
+    if (isAbsolute(trimmed)) {
+        return trimmed;
+    }
+    return resolve(cwd, trimmed);
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Find the first existing file path: optional explicit path, else scan `candidatePaths` under `cwd`.
+ */
+async function resolveFirstExistingPath(cwd, options) {
+    const { explicitPath, candidatePaths } = options;
+    if (explicitPath != null && explicitPath.trim() !== "") {
+        const resolved = resolvePathFromCwd(cwd, explicitPath);
+        return (await pathExists(resolved)) ? resolved : null;
+    }
+    for (const candidate of candidatePaths) {
+        const resolved = join(cwd, candidate);
+        if (await pathExists(resolved)) {
+            return resolved;
+        }
+    }
+    return null;
+}
+/** `file://` href for Node dynamic `import()` of a local module. */
+function toFileImportHref(filePath) {
+    const trimmed = filePath.trim();
+    if (trimmed.includes("://")) {
+        return trimmed;
+    }
+    return pathToFileURL(trimmed).href;
+}
+/** Native ESM import of a `.js` / `.mjs` config; supports `export default` or named export object. */
+async function importJsConfigModule(configPath) {
+    const mod = await import(toFileImportHref(configPath));
+    return mod.default ?? mod;
+}
+
+function isTaskRepoContext(value) {
+    if (value == null || typeof value !== "object") {
+        return false;
+    }
+    const record = value;
+    return typeof record.taskParamsValidator === "function" && typeof record.taskFn === "function";
+}
+/**
+ * Normalize a dynamically imported module into {@link TaskRepoContext}.
+ * Supported shapes:
+ * - `export default { taskParamsValidator, taskFn }`
+ * - `export { taskParamsValidator, taskFn }`
+ * - `export default taskFn` (validator becomes `() => true`)
+ */
+function normalizeRepoContextModule(moduleExports, taskTypeKey, exportName) {
+    if (moduleExports == null) {
+        return null;
+    }
+    const record = moduleExports;
+    const namedExport = exportName != null && exportName !== "" ? record[exportName] : undefined;
+    const defaultExport = record.default;
+    const candidate = namedExport ?? defaultExport ?? moduleExports;
+    let taskParamsValidator;
+    let taskFn;
+    if (typeof candidate === "function") {
+        taskFn = candidate;
+        taskParamsValidator = record.taskParamsValidator;
+    }
+    else if (typeof candidate === "object" && candidate != null) {
+        const ctx = candidate;
+        taskParamsValidator = ctx.taskParamsValidator;
+        taskFn = ctx.taskFn;
+    }
+    taskParamsValidator ??= record.taskParamsValidator;
+    taskFn ??= record.taskFn;
+    if (typeof taskFn !== "function") {
+        return null;
+    }
+    if (typeof taskParamsValidator !== "function") {
+        taskParamsValidator = () => true;
+    }
+    const fn = taskFn;
+    if (fn.displayName == null || fn.displayName === "") {
+        fn.displayName = taskTypeKey;
+    }
+    if (fn.taskTypeKey == null || fn.taskTypeKey === "") {
+        fn.taskTypeKey = taskTypeKey;
+    }
+    return {
+        taskParamsValidator: taskParamsValidator,
+        taskFn: fn,
+    };
+}
+function pickEntryScript(scripts) {
+    if (scripts.length === 0) {
+        return null;
+    }
+    const entry = scripts.find((script) => script.details.isEntry === true);
+    return entry ?? scripts[0];
+}
+function getScriptLoadKey(script) {
+    const { source, modulePath, hash } = script.details;
+    if (hash != null && hash !== "") {
+        return hash;
+    }
+    if (source != null && source !== "") {
+        return `source:${source.length}:${source.slice(0, 64)}`;
+    }
+    if (modulePath != null && modulePath !== "") {
+        return `path:${modulePath}`;
+    }
+    return script.id;
+}
+function assertScriptLoadable(details) {
+    const hasSource = details.source != null && details.source.trim() !== "";
+    const hasModulePath = details.modulePath != null && details.modulePath.trim() !== "";
+    return hasSource || hasModulePath;
+}
+
+const importedModuleCache = new Map();
+async function importFromFilePath(modulePath) {
+    return import(toFileImportHref(modulePath));
+}
+/** Resolve repo `details.url` to a value suitable for dynamic `import()`. */
+function resolveRepoEntryHref(url, cwd = process.cwd()) {
+    const trimmed = url.trim();
+    if (trimmed.includes("://")) {
+        return trimmed;
+    }
+    return toFileImportHref(resolvePathFromCwd(cwd, trimmed));
+}
+async function importFromSource(source, cacheKey) {
+    const hash = createHash("sha256").update(source).digest("hex").slice(0, 16);
+    const dir = join(tmpdir(), "target-supabase-sdk", "repo-scripts");
+    await mkdir(dir, { recursive: true });
+    const filePath = join(dir, `${cacheKey}-${hash}.mjs`);
+    await writeFile(filePath, source, "utf8");
+    return importFromFilePath(filePath);
+}
+async function loadRepoContextFromScript({ logger, script, taskTypeKey, }) {
+    const loadKey = getScriptLoadKey(script);
+    const cacheKey = `${taskTypeKey}@${loadKey}`;
+    const cached = importedModuleCache.get(cacheKey);
+    if (cached != null) {
+        logger.info("命中 Repo 脚本模块缓存", { topic: "repo", data: { cacheKey } });
+        return cached;
+    }
+    const { source, modulePath, exportName } = script.details;
+    try {
+        let moduleExports;
+        if (source != null && source.trim() !== "") {
+            logger.info("从 source 动态加载 Repo 脚本", { topic: "repo", data: { scriptId: script.id } });
+            moduleExports = await importFromSource(source, cacheKey);
+        }
+        else if (modulePath != null && modulePath.trim() !== "") {
+            logger.info("从 modulePath 动态加载 Repo 脚本", {
+                topic: "repo",
+                data: { scriptId: script.id, modulePath },
+            });
+            moduleExports = await importFromFilePath(modulePath);
+        }
+        else {
+            logger.warn("脚本缺少 source 或 modulePath", { topic: "repo", data: { scriptId: script.id } });
+            return null;
+        }
+        const context = normalizeRepoContextModule(moduleExports, taskTypeKey, exportName);
+        if (context == null) {
+            logger.warn("脚本模块未导出合法的 TaskRepoContext", {
+                topic: "repo",
+                data: { scriptId: script.id, exportName: exportName ?? "default" },
+            });
+            return null;
+        }
+        const loaded = { context, contentHash: loadKey };
+        importedModuleCache.set(cacheKey, loaded);
+        return loaded;
+    }
+    catch (error) {
+        logger.error("动态加载 Repo 脚本失败", {
+            topic: "repo",
+            data: { scriptId: script.id, error: error instanceof Error ? error.message : error },
+        });
+        return null;
+    }
+}
+async function loadRepoContextFromUrl({ logger, url, taskTypeKey, exportName, }) {
+    const href = resolveRepoEntryHref(url);
+    const cacheKey = `${taskTypeKey}@url:${href}`;
+    const cached = importedModuleCache.get(cacheKey);
+    if (cached != null) {
+        logger.info("命中 Repo URL 模块缓存", { topic: "repo", data: { cacheKey } });
+        return cached;
+    }
+    try {
+        logger.info("从 Repo URL 动态加载脚本", { topic: "repo", data: { url, href } });
+        const moduleExports = await import(href);
+        const context = normalizeRepoContextModule(moduleExports, taskTypeKey, exportName);
+        if (context == null) {
+            logger.warn("Repo URL 模块未导出合法的 TaskRepoContext", {
+                topic: "repo",
+                data: { url, exportName: exportName ?? "default" },
+            });
+            return null;
+        }
+        const loaded = { context, contentHash: cacheKey };
+        importedModuleCache.set(cacheKey, loaded);
+        return loaded;
+    }
+    catch (error) {
+        logger.error("从 Repo URL 动态加载失败", {
+            topic: "repo",
+            data: { url, error: error instanceof Error ? error.message : error },
+        });
+        return null;
+    }
+}
+/** Clear in-memory imported module cache (tests / hot reload). */
+function clearRepoScriptModuleCache() {
+    importedModuleCache.clear();
+}
+
+const localRepoRegistry = new Map();
+const remoteContextCache = new Map();
+function buildRemoteCacheKey(taskTypeKey, contentHash) {
+    return `${taskTypeKey}@${contentHash}`;
+}
+async function fetchRemoteRepo(taskTypeKey) {
+    const { data } = await getPossibleTarget({
+        filterList: [
+            { field: "category", operator: "eq", value: CategoryRepo.REPO },
+            { field: "value", operator: "eq", value: taskTypeKey },
+        ],
+    });
+    return data ?? null;
+}
+async function fetchRemoteScripts(taskTypeKey) {
+    const { data, error } = await supabase.client
+        .from("target")
+        .select("id, value, details")
+        .eq("category", TASK_REPO_SCRIPT_CATEGORY)
+        .eq("value", taskTypeKey);
+    if (error) {
+        throw error;
+    }
+    return (data ?? []);
+}
+async function loadLocalEntry(logger, entry, taskTypeKey) {
+    if (entry.kind === "context") {
+        return entry.context;
+    }
+    const loaded = await loadRepoContextFromScript({
+        logger,
+        script: {
+            id: `local:${taskTypeKey}`,
+            value: taskTypeKey,
+            details: {
+                manifestVersion: 0,
+                modulePath: entry.modulePath,
+                exportName: entry.exportName,
+                isEntry: true,
+            },
+        },
+        taskTypeKey,
+    });
+    return loaded?.context ?? null;
+}
+async function loadRemoteRepoContext(logger, taskTypeKey) {
+    logger.info("從 Supabase 加載 Repo", { topic: "repo", data: { taskTypeKey } });
+    const remoteRepo = await fetchRemoteRepo(taskTypeKey);
+    if (remoteRepo == null) {
+        const error = `Supabase 未找到 Repo (value=${taskTypeKey})`;
+        logger.warn(error, { topic: "repo", data: { taskTypeKey } });
+        return { context: null, error, failureReason: "REMOTE_REPO_NOT_FOUND" };
+    }
+    const repoUrl = remoteRepo.details?.url?.trim() ?? "";
+    const repoHash = remoteRepo.details?.hash?.trim() ?? repoUrl;
+    const cacheKey = buildRemoteCacheKey(taskTypeKey, repoHash);
+    const cached = remoteContextCache.get(cacheKey);
+    if (cached != null) {
+        logger.info("命中遠程 Repo 上下文緩存", { topic: "repo", data: { cacheKey } });
+        return { context: cached, resolvedVia: "remote" };
+    }
+    const scripts = await fetchRemoteScripts(taskTypeKey);
+    const entryScript = pickEntryScript(scripts);
+    let loaded = entryScript != null && assertScriptLoadable(entryScript.details)
+        ? await loadRepoContextFromScript({ logger, script: entryScript, taskTypeKey })
+        : null;
+    if (loaded == null && repoUrl !== "") {
+        logger.info("未找到 script 行，嘗試從 Repo.details.url 加載", {
+            topic: "repo",
+            data: { taskTypeKey, url: repoUrl },
+        });
+        loaded = await loadRepoContextFromUrl({ logger, url: repoUrl, taskTypeKey });
+    }
+    if (loaded == null) {
+        const error = `無法從 Repo 加載 TaskRepoContext (hasUrl=${repoUrl !== ""}, scriptCount=${scripts.length})`;
+        logger.warn(error, {
+            topic: "repo",
+            data: { taskTypeKey, hasUrl: repoUrl !== "", scriptCount: scripts.length },
+        });
+        return { context: null, error, failureReason: "REMOTE_REPO_LOAD_FAILED" };
+    }
+    remoteContextCache.set(cacheKey, loaded.context);
+    return { context: loaded.context, resolvedVia: "remote" };
+}
+const getRepoContext = async ({ logger, taskTypeKey, includeRemote = true, }) => {
+    const localEntry = localRepoRegistry.get(taskTypeKey);
+    if (localEntry != null) {
+        logger.info("使用本地註冊的 Repo", { topic: "repo", data: { taskTypeKey } });
+        const context = await loadLocalEntry(logger, localEntry, taskTypeKey);
+        if (context != null && isTaskRepoContext(context)) {
+            return { context: context, resolvedVia: "local" };
+        }
+        const error = "本地 Repo 模組加載失敗或未導出有效的 TaskRepoContext";
+        logger.warn(error, { topic: "repo", data: { taskTypeKey } });
+        return { context: null, error, failureReason: "LOCAL_REPO_LOAD_FAILED" };
+    }
+    if (!includeRemote) {
+        const error = `本地未註冊 Repo (value=${taskTypeKey})`;
+        logger.warn(error, { topic: "repo", data: { taskTypeKey, includeRemote: false } });
+        return { context: null, error, failureReason: "LOCAL_REPO_NOT_FOUND" };
+    }
+    try {
+        const result = await loadRemoteRepoContext(logger, taskTypeKey);
+        if (result.context != null && isTaskRepoContext(result.context)) {
+            return { context: result.context, resolvedVia: "remote" };
+        }
+        return {
+            context: null,
+            error: result.error ?? "遠程 Repo 上下文無效",
+            failureReason: result.failureReason ?? "REMOTE_REPO_LOAD_FAILED",
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error("從 Supabase 加載 Repo 失敗", {
+            topic: "repo",
+            data: { taskTypeKey, error: message },
+        });
+        return { context: null, error: message, failureReason: "REMOTE_REPO_LOAD_FAILED" };
+    }
+};
+/** Register an in-process TaskRepoContext (highest priority — no Supabase fetch). */
+function registerLocalRepoContext(taskTypeKey, context) {
+    if (!isTaskRepoContext(context)) {
+        throw new Error("[RepoManager] Invalid TaskRepoContext");
+    }
+    localRepoRegistry.set(taskTypeKey, { kind: "context", context });
+}
+/** Register a local ESM module path; loaded via dynamic import when the task runs. */
+function registerLocalModule(taskTypeKey, modulePath, exportName) {
+    if (modulePath.trim() === "") {
+        throw new Error("[RepoManager] modulePath must not be empty");
+    }
+    localRepoRegistry.set(taskTypeKey, { kind: "modulePath", modulePath, exportName });
+}
+function unregisterLocalRepo(taskTypeKey) {
+    localRepoRegistry.delete(taskTypeKey);
+}
+function hasLocalRepo(taskTypeKey) {
+    return localRepoRegistry.has(taskTypeKey);
+}
+function getRegisteredLocalTaskTypeKeys$1() {
+    return [...localRepoRegistry.keys()];
+}
+function clearRemoteContextCache() {
+    remoteContextCache.clear();
+}
+const RepoManager = {
+    getRepoContext,
+    registerLocalRepoContext,
+    registerLocalModule,
+    unregisterLocalRepo,
+    hasLocalRepo,
+    getRegisteredLocalTaskTypeKeys: getRegisteredLocalTaskTypeKeys$1,
+    clearRemoteContextCache,
+    clearRepoScriptModuleCache,
+};
+
+const EMPTY_RESULT = {
+    status: "not_configured",
+    registered: [],
+    skipped: [],
+    errors: [],
+};
+let bootstrapCache = { fingerprint: null, lastResult: null };
+let bootstrapInFlight = null;
+function parseRootConfig(raw, configPath) {
+    if (raw == null || typeof raw !== "object") {
+        throw new Error(`Root config must export an object: ${configPath}`);
+    }
+    const record = raw;
+    const taskDir = record.taskDir;
+    if (typeof taskDir !== "string" || taskDir.trim() === "") {
+        throw new Error(`Root config.taskDir must be a non-empty string: ${configPath}`);
+    }
+    return { taskDir: taskDir.trim() };
+}
+function parseTaskPackageConfig(raw, configPath) {
+    if (raw == null || typeof raw !== "object") {
+        throw new Error(`Task config must export an object: ${configPath}`);
+    }
+    const record = raw;
+    const taskTypeKey = record.taskTypeKey;
+    const entry = record.entry;
+    if (typeof taskTypeKey !== "string" || taskTypeKey.trim() === "") {
+        throw new Error(`taskTypeKey must be a non-empty string: ${configPath}`);
+    }
+    if (typeof entry !== "string" || entry.trim() === "") {
+        throw new Error(`entry must be a non-empty string: ${configPath}`);
+    }
+    return {
+        taskTypeKey: taskTypeKey.trim(),
+        entry: entry.trim(),
+        exportName: typeof record.exportName === "string" ? record.exportName : undefined,
+        displayName: typeof record.displayName === "string" ? record.displayName : undefined,
+        enabled: record.enabled !== false,
+    };
+}
+function finalizeStatus(result) {
+    if (result.errors.length > 0 && result.registered.length === 0) {
+        return "failed";
+    }
+    if (result.registered.length === 0) {
+        return "empty";
+    }
+    return "loaded";
+}
+async function computeConfigFingerprint(rootConfigPath, tasksRoot) {
+    const rootStat = await stat(rootConfigPath);
+    const tasksRootStat = await stat(tasksRoot);
+    const entries = await readdir(tasksRoot, { withFileTypes: true });
+    const configMtims = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const configPath = join(tasksRoot, entry.name, TASK_LOCAL_PACKAGE_CONFIG_FILENAME);
+        if (await pathExists(configPath)) {
+            const configStat = await stat(configPath);
+            configMtims.push(configStat.mtimeMs);
+        }
+    }
+    configMtims.sort((a, b) => a - b);
+    return `${rootConfigPath}:${rootStat.mtimeMs}:${tasksRoot}:${tasksRootStat.mtimeMs}:${configMtims.join(",")}`;
+}
+function canUseCachedBootstrap(fingerprint, forTaskTypeKey) {
+    if (bootstrapCache.fingerprint !== fingerprint || bootstrapCache.lastResult == null) {
+        return null;
+    }
+    if (forTaskTypeKey != null && forTaskTypeKey !== "") {
+        if (!RepoManager.hasLocalRepo(forTaskTypeKey)) {
+            return null;
+        }
+    }
+    return { ...bootstrapCache.lastResult, cached: true };
+}
+async function runBootstrapScan(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const rootConfigPath = await resolveFirstExistingPath(cwd, {
+        explicitPath: options.rootConfigPath,
+        candidatePaths: [TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH, TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH],
+    });
+    if (rootConfigPath == null) {
+        const result = {
+            ...EMPTY_RESULT,
+            message: `No root config (tried ${TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH}, ${TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH})`,
+        };
+        bootstrapCache = { fingerprint: null, lastResult: result };
+        return result;
+    }
+    const result = {
+        registered: [],
+        skipped: [],
+        errors: [],
+    };
+    try {
+        const rootRaw = await importJsConfigModule(rootConfigPath);
+        const { taskDir } = parseRootConfig(rootRaw, rootConfigPath);
+        const tasksRoot = resolvePathFromConfigFile(rootConfigPath, taskDir);
+        if (!(await pathExists(tasksRoot))) {
+            const failed = {
+                status: "failed",
+                message: `taskDir does not exist: ${tasksRoot}`,
+                ...result,
+            };
+            bootstrapCache = { fingerprint: null, lastResult: failed };
+            return failed;
+        }
+        const fingerprint = await computeConfigFingerprint(rootConfigPath, tasksRoot);
+        const cached = canUseCachedBootstrap(fingerprint, options.forTaskTypeKey);
+        if (cached != null) {
+            return cached;
+        }
+        const entries = await readdir(tasksRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const taskPackageDir = join(tasksRoot, entry.name);
+            const taskConfigPath = join(taskPackageDir, TASK_LOCAL_PACKAGE_CONFIG_FILENAME);
+            if (!(await pathExists(taskConfigPath))) {
+                result.skipped.push({ taskDir: taskPackageDir, reason: "missing task.config.js" });
+                continue;
+            }
+            try {
+                const taskRaw = await importJsConfigModule(taskConfigPath);
+                const taskConfig = parseTaskPackageConfig(taskRaw, taskConfigPath);
+                if (taskConfig.enabled === false) {
+                    result.skipped.push({ taskDir: taskPackageDir, reason: "disabled in task.config.js" });
+                    continue;
+                }
+                const entryPath = resolvePathFromBaseDir(taskPackageDir, taskConfig.entry);
+                if (!(await pathExists(entryPath))) {
+                    throw new Error(`entry module not found: ${entryPath}`);
+                }
+                RepoManager.registerLocalModule(taskConfig.taskTypeKey, entryPath, taskConfig.exportName);
+                result.registered.push(taskConfig.taskTypeKey);
+            }
+            catch (error) {
+                result.errors.push({
+                    taskDir: taskPackageDir,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        const status = finalizeStatus(result);
+        const finalResult = {
+            status,
+            message: status === "empty" ? `Root config loaded but no tasks registered under ${tasksRoot}` : undefined,
+            ...result,
+        };
+        bootstrapCache = { fingerprint, lastResult: finalResult };
+        return finalResult;
+    }
+    catch (error) {
+        const failed = {
+            status: "failed",
+            message: error instanceof Error ? error.message : String(error),
+            ...result,
+        };
+        bootstrapCache = { fingerprint: null, lastResult: failed };
+        return failed;
+    }
+}
+/**
+ * Discover local task packages from config files and register them with {@link RepoManager}.
+ *
+ * **Never throws** for missing root config — returns `{ status: "not_configured" }`.
+ *
+ * Re-scans are skipped when the config fingerprint is unchanged (root config + taskDir mtimes).
+ * Concurrent calls share a single in-flight scan (single-flight).
+ *
+ * Host app layout (recommended):
+ * ```
+ * ./config/task.config.js       → { taskDir: "../tasks" }
+ * ./tasks/my-task/task.config.js
+ * ./tasks/my-task/index.mjs
+ * ```
+ *
+ * `taskDir` / `entry` paths are relative to **their config file's directory** (see config-file-relative-paths skill).
+ *
+ * Legacy fallback: `./task.config.js` at project root (`taskDir: "./tasks"`).
+ */
+async function bootstrapLocalTasks(options = {}) {
+    if (bootstrapInFlight != null) {
+        return bootstrapInFlight;
+    }
+    bootstrapInFlight = runBootstrapScan(options).finally(() => {
+        bootstrapInFlight = null;
+    });
+    return bootstrapInFlight;
+}
+/** Clear fingerprint cache (tests / hot-reload tooling). */
+function clearBootstrapLocalTasksCache() {
+    bootstrapCache = { fingerprint: null, lastResult: null };
+    bootstrapInFlight = null;
+}
+function getRegisteredLocalTaskTypeKeys() {
+    return RepoManager.getRegisteredLocalTaskTypeKeys();
+}
+
+function validateTaskParams(validator, taskParams, logger) {
+    try {
+        return validator(taskParams) === true;
+    }
+    catch (error) {
+        logger.warn("taskParamsValidator 拋出異常", {
+            topic: "task",
+            data: { error: error instanceof Error ? error.message : error },
+        });
+        return false;
+    }
+}
+function invalid(params) {
+    return { isValid: false, ...params };
+}
+/**
+ * Resolve task Repo context and validate `params` via `taskParamsValidator`.
+ *
+ * Repo resolution uses {@link RepoManager.getRepoContext}:
+ * local registry first; when no local entry and `includeRemote`, loads from Supabase.
+ */
+async function validateTaskRepoAndParams({ logger, taskTypeKey, params, bootstrapLocal = false, bootstrapLocalOptions, includeRemote = true, }) {
+    if (params == null) {
+        return invalid({
+            reason: "MISSING_PARAMS",
+            code: ResultCode.PARAMS_NOT_VALID,
+            message: "任務缺少 params",
+            step: "params",
+        });
+    }
+    if (bootstrapLocal) {
+        const bootstrap = await bootstrapLocalTasks({
+            ...bootstrapLocalOptions,
+            forTaskTypeKey: taskTypeKey,
+        });
+        logger.debug("本地任務 bootstrap 完成", {
+            topic: "task",
+            data: {
+                taskTypeKey,
+                step: "local_bootstrap",
+                status: bootstrap.status,
+                registered: bootstrap.registered,
+                cached: bootstrap.cached ?? false,
+                message: bootstrap.message,
+            },
+        });
+    }
+    logger.debug("開始解析 Repo 上下文", {
+        topic: "task",
+        data: { taskTypeKey, step: "repo_load", includeRemote },
+    });
+    const { context: repoContext, error: repoError, failureReason, resolvedVia, } = await RepoManager.getRepoContext({
+        logger,
+        taskTypeKey,
+        includeRemote,
+    });
+    if (repoContext == null) {
+        return invalid({
+            reason: failureReason ?? "REMOTE_REPO_LOAD_FAILED",
+            code: ResultCode.REPO_NOT_VALID,
+            message: repoError ?? "無法加載 Repo 上下文",
+            step: "repo_load",
+        });
+    }
+    logger.debug("Repo 上下文解析完成", {
+        topic: "task",
+        data: { taskTypeKey, step: "repo_load", resolvedVia },
+    });
+    if (repoContext.taskFn.taskTypeKey !== taskTypeKey) {
+        return invalid({
+            reason: "TASK_TYPE_KEY_MISMATCH",
+            code: ResultCode.REPO_NOT_VALID,
+            message: `taskFn.taskTypeKey (${repoContext.taskFn.taskTypeKey}) 與 task.value (${taskTypeKey}) 不一致`,
+            step: "task_type_key",
+        });
+    }
+    logger.debug("開始校驗任務參數", { topic: "task", data: { taskTypeKey, step: "params_validation" } });
+    if (!validateTaskParams(repoContext.taskParamsValidator, params, logger)) {
+        return invalid({
+            reason: "PARAMS_VALIDATION_FAILED",
+            code: ResultCode.PARAMS_NOT_VALID,
+            message: "任務參數校驗失敗",
+            step: "params_validation",
+        });
+    }
+    logger.debug("任務參數校驗通過", { topic: "task", data: { taskTypeKey, step: "params_validation" } });
+    return { isValid: true, repoContext };
+}
+const TaskRepoValidation = {
+    validate: validateTaskRepoAndParams,
+};
+
+function logLocalBootstrap(logger, bootstrap) {
+    switch (bootstrap.status) {
+        case "not_configured":
+            logger.info("未找到本地任務配置，跳過本地註冊", {
+                topic: LOG_TOPIC_TASK,
+                data: { message: bootstrap.message },
+            });
+            break;
+        case "failed":
+            logger.warn("本地任務註冊失敗", {
+                topic: LOG_TOPIC_TASK,
+                data: { message: bootstrap.message, errors: bootstrap.errors },
+            });
+            break;
+        case "empty":
+            logger.info("本地任務掃描完成，無已註冊任務", {
+                topic: LOG_TOPIC_TASK,
+                data: { message: bootstrap.message, skipped: bootstrap.skipped },
+            });
+            break;
+        case "loaded":
+            logger.info("本地任務註冊完成", {
+                topic: LOG_TOPIC_TASK,
+                data: {
+                    registered: bootstrap.registered,
+                    skipped: bootstrap.skipped,
+                    errors: bootstrap.errors,
+                },
+            });
+            break;
+    }
+}
+/**
+ * Worker startup: discover local task packages + remote Repo rows, merge into `availableTaskList`.
+ *
+ * - Local: {@link bootstrapLocalTasks} → registers modules in {@link RepoManager}
+ * - Remote: {@link getScanRemoteRepoValues} with {@link TASK_REPO_USAGE}
+ * - Merge: union of both; execution still prefers local registry in {@link RepoManager.getRepoContext}
+ *
+ * @throws When merged list is empty (no task types to claim).
+ */
+async function registerTasks({ logger, local: localOptions, includeRemote = true, }) {
+    logger.debug("開始註冊任務（本地 + 遠程）", { topic: LOG_TOPIC_TASK });
+    const local = await bootstrapLocalTasks(localOptions ?? {});
+    logLocalBootstrap(logger, local);
+    let remoteValues = [];
+    if (includeRemote) {
+        logger.debug("查詢遠程 Repo 列表", {
+            topic: LOG_TOPIC_TASK,
+            data: { usage: TASK_REPO_USAGE },
+        });
+        const { data, error: remoteError } = await getScanRemoteRepoValues({ usage: TASK_REPO_USAGE });
+        if (remoteError) {
+            throw new Error(remoteError.message);
+        }
+        remoteValues = data ?? [];
+        logger.debug("遠程 Repo 查詢完成", {
+            topic: LOG_TOPIC_TASK,
+            data: { count: remoteValues.length, values: remoteValues },
+        });
+    }
+    const availableTaskList = [...new Set([...local.registered, ...remoteValues])];
+    if (availableTaskList.length === 0) {
+        throw new Error("任務註冊失敗：本地與遠程均無可用任務類型");
+    }
+    logger.success("任務註冊完成", {
+        topic: LOG_TOPIC_TASK,
+        data: {
+            availableTaskList,
+            localRegistered: local.registered,
+            remoteValues,
+        },
+    });
+    return {
+        availableTaskList,
+        local,
+        remote: { values: remoteValues },
+        includeRemote,
+    };
+}
+/** 将 taskFn 与 params 闭包绑定，供 TaskNode 无参调用 `await taskFn()` */
+function bindTaskFn(taskFn, taskParams) {
+    const run = async () => taskFn(taskParams);
+    return Object.assign(run, {
+        displayName: taskFn.displayName,
+        taskTypeKey: taskFn.taskTypeKey,
+    });
+}
+/**
+ * 將 Supabase 認領到的 Task 解析為可執行的 `ExecutableTaskFn`。
+ *
+ * 流程：
+ * 1. 從 task.details 取出 `params`；`task.value` 作為 taskTypeKey（同 {@link Repo.value}）
+ * 2. {@link TaskRepoValidation.validate} — 本地註冊優先；未命中時可選遠端（`includeRemote`）
+ *    Worker 在 registry 未命中時會補掃本地（`local_bootstrap_on_miss`）
+ * 3. bindTaskFn，返回閉包後的無參執行函數
+ *
+ * 失敗時返回 `{ isSuccess: false, code, message, reason, step }`（不 throw）。
+ */
+const prepareTask = async ({ logger, task, includeRemote = true, bootstrapLocalOptions, }) => {
+    const fail = (params) => {
+        logger.warn(params.message, {
+            topic: LOG_TOPIC_TASK,
+            data: {
+                taskId: task.id,
+                taskTypeKey: task.value,
+                reason: params.reason,
+                step: params.step,
+            },
+        });
+        return {
+            isSuccess: false,
+            taskFn: null,
+            code: params.code,
+            message: params.message,
+            reason: params.reason,
+            step: params.step,
+        };
+    };
+    const { id: taskId, name: taskName, value: taskTypeKey, details } = task;
+    logger.debug(`開始準備任務 ${taskName}-${taskTypeKey}`, {
+        topic: LOG_TOPIC_TASK,
+        data: { taskId, taskName, taskTypeKey },
+    });
+    const { params: taskParams } = details;
+    if (!getRegisteredLocalTaskTypeKeys().includes(taskTypeKey)) {
+        const bootstrap = await bootstrapLocalTasks({
+            ...bootstrapLocalOptions,
+            forTaskTypeKey: taskTypeKey,
+        });
+        logger.debug("本地 registry 未命中，補掃本地任務", {
+            topic: LOG_TOPIC_TASK,
+            data: {
+                taskId,
+                taskTypeKey,
+                step: "local_bootstrap_on_miss",
+                status: bootstrap.status,
+                registered: bootstrap.registered,
+                cached: bootstrap.cached ?? false,
+                message: bootstrap.message,
+            },
+        });
+    }
+    const validation = await TaskRepoValidation.validate({
+        logger,
+        taskTypeKey,
+        params: taskParams,
+        includeRemote,
+    });
+    if (!validation.isValid) {
+        return fail({
+            reason: validation.reason,
+            code: validation.code,
+            message: validation.message,
+            step: validation.step,
+        });
+    }
+    const { repoContext } = validation;
+    logger.debug("Repo 上下文加載成功", {
+        topic: LOG_TOPIC_TASK,
+        data: {
+            taskTypeKey,
+            taskFnDisplayName: repoContext.taskFn.displayName,
+            step: "repo_load",
+        },
+    });
+    const boundTaskFn = bindTaskFn(repoContext.taskFn, taskParams);
+    logger.debug("任務準備完成", {
+        topic: LOG_TOPIC_TASK,
+        data: {
+            taskId,
+            taskTypeKey,
+            displayName: boundTaskFn.displayName,
+            step: "bind",
+        },
+    });
+    return {
+        isSuccess: true,
+        taskFn: boundTaskFn,
+    };
+};
+const TaskManager = {
+    registerTasks,
+    prepareTask,
+    bootstrapLocalTasks,
+    getRegisteredLocalTaskTypeKeys,
+    clearBootstrapLocalTasksCache,
+};
+
+/**
+ * Task worker node: commands → heartbeat → claim & execute tasks.
+ * Built on {@link BaseNodeRuntime}.
+ */
+class TaskNode extends BaseNodeRuntime {
+    _availableTaskList = [];
+    _includeRemote = true;
+    get availableTaskList() {
+        return [...this._availableTaskList];
+    }
+    constructor() {
+        super("taskNode");
+    }
+    async onBeforeRegisterNode(logger) {
+        const { availableTaskList, includeRemote } = await TaskManager.registerTasks({ logger });
+        this._availableTaskList = availableTaskList;
+        this._includeRemote = includeRemote;
+    }
+    async runLoopSteps(ctx, heartbeatOk) {
+        if (!heartbeatOk) {
+            const logger = createLogger({
+                scope: createScope({
+                    module: `${this.runtimeModule}-runLoopSteps`,
+                    traceId: ctx.loopTraceId,
+                    labels: { nodeId: ctx.nodeId },
+                }),
+            });
+            logger.warn("心跳失敗，本輪跳過任務認領", { topic: LOG_TOPIC_NODE });
+            return;
+        }
+        await this.runAsWorker(ctx);
+    }
+    async runAsWorker(ctx) {
+        const { loopTraceId, nodeId } = ctx;
+        const loopScope = createScope({ module: "runAsWorker", traceId: loopTraceId, labels: { nodeId } });
+        const logger = createLogger({ scope: loopScope });
+        const availableTaskList = this.availableTaskList;
+        if (availableTaskList.length === 0) {
+            logger.warn("未配置可認領任務類型，跳過本輪", { topic: LOG_TOPIC_TASK });
+            return;
+        }
+        logger.debug("向 Supabase 認領任務", {
+            topic: LOG_TOPIC_TASK,
+            data: { availableTaskList },
+        });
+        const { data: task, error: claimError } = await patchClaimTask({
+            nodeId,
+            availableTaskList: [...availableTaskList],
+            traceId: loopTraceId,
+        });
+        if (claimError) {
+            if (isOptimisticLockResponse(claimError)) {
+                logger.debug("認領競爭失敗，本輪無可認領任務", {
+                    topic: LOG_TOPIC_TASK,
+                    data: { availableTaskList },
+                });
+                return;
+            }
+            logger.error("認領任務失敗", {
+                topic: LOG_TOPIC_TASK,
+                data: {
+                    availableTaskList,
+                    error: claimError.message,
+                    code: claimError.code,
+                },
+            });
+            return;
+        }
+        if (task == null) {
+            logger.debug("本輪無匹配的 TODO 任務", {
+                topic: LOG_TOPIC_TASK,
+                data: { availableTaskList },
+            });
+            return;
+        }
+        const taskTraceId = task.details.traceId ?? CRITICAL_UNKNOWN_TASK_TRACE_ID;
+        const taskScope = createScope({
+            module: "runAsWorker",
+            traceId: loopTraceId,
+            labels: { nodeId },
+            traceParentId: taskTraceId,
+        });
+        const taskLogger = createLogger({ scope: taskScope });
+        taskLogger.success("認領任務成功，準備執行", {
+            topic: LOG_TOPIC_TASK,
+            data: {
+                taskId: task.id,
+                taskName: task.name,
+                taskTypeKey: task.value,
+                taskStatus: task.details.status,
+            },
+        });
+        const prepareLogger = createLogger({ scope: withModule(taskScope, "prepareTask") });
+        const prepareResult = await TaskManager.prepareTask({
+            logger: prepareLogger,
+            task,
+            includeRemote: this._includeRemote,
+        });
+        const { isSuccess: isPrepareSuccess, taskFn, code, message, reason, step } = prepareResult;
+        if (!isPrepareSuccess || taskFn == null) {
+            prepareLogger.critical("任務準備失敗，無法繼續執行，中止任務並 RESET 為 OPEN", {
+                topic: LOG_TOPIC_TASK,
+                data: {
+                    taskId: task.id,
+                    taskTypeKey: task.value,
+                    code,
+                    message,
+                    reason,
+                    step,
+                },
+            });
+            await this.abortTaskRun({
+                logger: prepareLogger,
+                taskId: task.id,
+                nodeId,
+                traceId: taskTraceId,
+            });
+            return;
+        }
+        logger.success("任務準備完成", {
+            topic: LOG_TOPIC_TASK,
+            data: {
+                taskId: task.id,
+                taskName: task.name,
+                taskTypeKey: task.value,
+                displayName: taskFn.displayName,
+            },
+        });
+        const executeLogger = createLogger({ scope: withModule(taskScope, "executeTask") });
+        const onExecuteAbort = async (error) => {
+            executeLogger.critical("任務執行遇到未知錯誤，中止任務並 RESET 為 OPEN", {
+                topic: LOG_TOPIC_TASK,
+                data: {
+                    taskId: task.id,
+                    taskTypeKey: task.value,
+                    taskName: task.name,
+                    displayName: taskFn.displayName,
+                    error: getErrorMessage(error),
+                },
+            });
+            await this.abortTaskRun({
+                logger: executeLogger,
+                taskId: task.id,
+                nodeId,
+                traceId: taskTraceId,
+            });
+        };
+        executeLogger.info("開始執行業務邏輯", {
+            topic: LOG_TOPIC_TASK,
+            data: { taskId: task.id, displayName: taskFn.displayName },
+        });
+        const startTime = Date.now();
+        let result = null;
+        try {
+            result = await taskFn();
+        }
+        catch (error) {
+            await onExecuteAbort(toError(error));
+            return;
+        }
+        if (result == null) {
+            await onExecuteAbort(new Error("任務執行結果為空"));
+            return;
+        }
+        const { isSuccess: isTaskSuccess, cost, extra } = result ?? { isSuccess: false, cost: 0, extra: null };
+        if (isTaskSuccess) {
+            await this.finalizeTaskRun("success", {
+                logger: executeLogger,
+                taskId: task.id,
+                taskTypeKey: task.value,
+                nodeId,
+                cost,
+                extra,
+                traceId: taskTraceId,
+            });
+        }
+        else {
+            await this.finalizeTaskRun("failure", {
+                logger: executeLogger,
+                taskId: task.id,
+                taskTypeKey: task.value,
+                nodeId,
+                cost,
+                extra,
+                traceId: taskTraceId,
+            });
+        }
+        const duration = Date.now() - startTime;
+        executeLogger.info("業務邏輯執行結束", {
+            topic: LOG_TOPIC_TASK,
+            data: {
+                taskId: task.id,
+                taskName: task.name,
+                taskTypeKey: task.value,
+                displayName: taskFn.displayName,
+                durationMs: duration,
+            },
+        });
+    }
+    async abortTaskRun(params) {
+        const { logger, taskId, nodeId, traceId, extra } = params;
+        const logData = { taskId, nodeId };
+        const extraValue = typeof extra === "string" ? extra : undefined;
+        const { error } = await patchChangeTaskStatus({
+            id: taskId,
+            action: TaskStatusAction.RESET,
+            nodeId,
+            extra: extraValue,
+            traceId,
+        });
+        if (error) {
+            logger.error(error.message, { topic: LOG_TOPIC_TASK, data: logData });
+            return false;
+        }
+        logger.info("任務已中止並 RESET 為 OPEN", { topic: LOG_TOPIC_TASK, data: logData });
+        return true;
+    }
+    async finalizeTaskRun(outcome, params) {
+        const { logger, taskId, nodeId, taskTypeKey, cost, extra, traceId } = params;
+        const outcomePrefix = outcome === "success" ? "任務成功" : "任務失敗";
+        const logData = {
+            taskTypeKey,
+            taskId,
+            nodeId,
+            ...(extra != null && extra !== "" ? { extra } : {}),
+        };
+        const extraValue = typeof extra === "string" ? extra : undefined;
+        const { error: changeTaskStatusError } = outcome === "success"
+            ? await patchChangeTaskStatus({
+                id: taskId,
+                action: TaskStatusAction.FINISH,
+                nodeId,
+                cost,
+                extra: extraValue,
+                traceId,
+            })
+            : await patchChangeTaskStatus({
+                id: taskId,
+                action: TaskStatusAction.RESET,
+                nodeId,
+                extra: extraValue,
+                traceId,
+            });
+        if (changeTaskStatusError) {
+            const upperMessage = `${outcomePrefix}但是更新 TaskStatus 失敗，產生孤兒 Task，請儘快排查問題`;
+            logger.critical(upperMessage, { topic: LOG_TOPIC_TASK, data: logData });
+            // TODO: 需要處理孤兒 Task
+            throw new Error(upperMessage);
+        }
+        logger.info("更新 TaskStatus 成功", { topic: LOG_TOPIC_TASK, data: logData });
+        if (outcome === "success") {
+            logger.success("任務執行結束，業務邏輯成功", { topic: LOG_TOPIC_TASK, data: logData });
+        }
+        else {
+            logger.warn("任務執行結束，業務邏輯失敗", { topic: LOG_TOPIC_TASK, data: logData });
+        }
+    }
+}
+
+/**
+ * Create a task row with publish-time Repo + params validation.
+ * **Node entry only** — requires local Repo bootstrap and {@link TaskRepoValidation}.
+ *
+ * @see target-supabase-sdk/node
+ */
+const postTaskWithValidation = validateWithSchema(postTaskSchema, "postTaskSchema")(async ({ name, value, params, taskStatus, tagList, extra, traceId, traceParentId }) => {
+    const taskTraceId = traceId?.trim() || logManager.generateTraceId();
+    const logger = createLogger({
+        module: "postTaskWithValidation",
+        traceId: taskTraceId,
+        traceParentId: traceParentId ?? null,
+    });
+    const validation = await TaskRepoValidation.validate({
+        logger,
+        taskTypeKey: value,
+        params,
+        bootstrapLocal: true,
+    });
+    if (!validation.isValid) {
+        logger.warn(validation.message, {
+            topic: "task",
+            data: {
+                taskTypeKey: value,
+                reason: validation.reason,
+                step: validation.step,
+            },
+        });
+        return generateResponse.error(validation.message, undefined, String(validation.code));
+    }
+    return createTaskRow({ name, value, params, taskStatus, tagList, extra, traceParentId, taskTraceId }, logger);
+});
+
+var CategoryTrigger;
+(function (CategoryTrigger) {
+    CategoryTrigger["TRIGGER"] = "trigger";
+})(CategoryTrigger || (CategoryTrigger = {}));
+var TriggerStatus;
+(function (TriggerStatus) {
+    TriggerStatus["ENABLED"] = "ENABLED";
+    TriggerStatus["DISABLED"] = "DISABLED";
+    TriggerStatus["PAUSED"] = "PAUSED";
+})(TriggerStatus || (TriggerStatus = {}));
+
+const TRIGGER_STATUS_FIELD = "details->>status";
+const traceIdSchema = z.string().trim().min(1).optional();
+const dailyScheduleSchema = z.object({
+    kind: z.literal("daily"),
+    hour: z.number().int().min(0).max(23),
+    minute: z.number().int().min(0).max(59),
+});
+const postTaskActionSchema = z.object({
+    kind: z.literal("post_task"),
+    taskTypeKey: z.string().trim().min(1),
+    taskParams: z.unknown(),
+    taskName: z.string().trim().min(1).optional(),
+    taskStatus: z.enum([TaskStatus.OPEN, TaskStatus.TODO]).optional(),
+});
+const postTriggerSchema = z.object({
+    name: z.string().trim().min(1),
+    value: z.string().trim().min(1),
+    status: z.nativeEnum(TriggerStatus).optional().default(TriggerStatus.ENABLED),
+    schedule: dailyScheduleSchema,
+    action: postTaskActionSchema,
+    tagList: z.array(z.string()).optional().default([]),
+    traceId: traceIdSchema,
+});
+const scanEnabledTriggersSchema = z.object({
+    traceId: traceIdSchema,
+});
+const patchTriggerFiredSchema = z.object({
+    triggerId: z.string().trim().min(1),
+    fireKey: z.string().trim().min(1),
+    expectedLastFireKey: z.string().nullable().optional(),
+    traceId: traceIdSchema,
+});
+function enabledTriggerFilter() {
+    return [{ field: TRIGGER_STATUS_FIELD, operator: "eq", value: TriggerStatus.ENABLED }];
+}
+/** List all ENABLED triggers (Phase 1: in-memory due check). */
+const scanEnabledTriggers = validateWithSchema(scanEnabledTriggersSchema, "scanEnabledTriggersSchema")(async ({ traceId }) => {
+    const logger = createLogger({ module: "scanEnabledTriggers", traceId });
+    try {
+        const { data: triggerList } = await scanTargetList({
+            category: CategoryTrigger.TRIGGER,
+            filterList: enabledTriggerFilter(),
+            orderBy: { field: "created_at", ascending: true },
+        });
+        const rows = triggerList ?? [];
+        logger.debug("已掃描 ENABLED Trigger", {
+            topic: "trigger",
+            data: { count: rows.length },
+        });
+        return generateResponse.success(rows);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return generateResponse.error(message);
+    }
+});
+/** Create a trigger row (scheduler / admin). */
+const postTrigger = validateWithSchema(postTriggerSchema, "postTriggerSchema")(async ({ name, value, status, schedule, action, tagList, traceId }) => {
+    const logger = createLogger({ module: "postTrigger", traceId });
+    const details = {
+        manifestVersion: 0,
+        status,
+        schedule: schedule,
+        action: action,
+        lastFiredAt: null,
+        lastFireKey: null,
+    };
+    const result = await createTarget({
+        payload: { name, value, status, schedule, action, tagList, traceId },
+        createFn: () => ({
+            name,
+            value,
+            category: CategoryTrigger.TRIGGER,
+            tagList,
+            details,
+        }),
+    });
+    logger.info("Trigger 已創建", {
+        topic: "trigger",
+        data: { triggerId: result.data?.id, triggerKey: value, status },
+    });
+    return result;
+});
+/**
+ * Mark trigger as fired for `fireKey`.
+ * When `expectedLastFireKey` is set, uses optimistic lock on that field.
+ */
+const patchTriggerFired = validateWithSchema(patchTriggerFiredSchema, "patchTriggerFiredSchema")(async ({ triggerId, fireKey, expectedLastFireKey, traceId }) => {
+    const logger = createLogger({ module: "patchTriggerFired", traceId });
+    const now = Date.now();
+    try {
+        const optimisticLockFilterList = expectedLastFireKey != null && expectedLastFireKey !== ""
+            ? [{ field: "details->>lastFireKey", operator: "eq", value: expectedLastFireKey }]
+            : [];
+        const data = await updateTargetDetails({
+            id: triggerId,
+            optimisticLockFilterList,
+            updateFn: (current) => ({
+                ...current,
+                lastFireKey: fireKey,
+                lastFiredAt: now,
+            }),
+        });
+        logger.success("Trigger 觸發記錄已更新", {
+            topic: "trigger",
+            data: { triggerId, fireKey },
+        });
+        return generateResponse.success(data);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn("Trigger 觸發記錄更新失敗", {
+            topic: "trigger",
+            data: { triggerId, fireKey, error: message },
+        });
+        return generateResponse.error(message);
+    }
+});
+
+const LOG_TOPIC_TRIGGER = "trigger";
+/** Fixed main-loop interval for {@link TriggerNode} (ms). */
+const TRIGGER_LOOP_INTERVAL_MS = 60_000;
+/** Default extra retries after first failure within one runner tick. */
+const TRIGGER_RUNNER_DEFAULT_RETRY_COUNT = 3;
+/** Default delay between retry attempts within the same tick (ms). */
+const TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS = 0;
+
+const runnerRegistry = new Map();
+let registrationClosed = false;
+function normalizeRunnerKey(key) {
+    const normalized = key.trim();
+    if (normalized.length === 0) {
+        throw new Error("[TriggerManager] key must be a non-empty string");
+    }
+    return normalized;
+}
+function tryNormalizeRunnerKey(key) {
+    const normalized = key.trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function validateRunnerOptions(options) {
+    if (!Number.isFinite(options.intervalMs) || options.intervalMs < 1) {
+        throw new Error(`[TriggerManager] intervalMs must be a positive number, got ${options.intervalMs}`);
+    }
+    const retryCount = options.retryCount ?? TRIGGER_RUNNER_DEFAULT_RETRY_COUNT;
+    if (!Number.isInteger(retryCount) || retryCount < 0) {
+        throw new Error(`[TriggerManager] retryCount must be a non-negative integer, got ${retryCount}`);
+    }
+    const initialDelayMs = options.initialDelayMs ?? 0;
+    if (!Number.isFinite(initialDelayMs) || initialDelayMs < 0) {
+        throw new Error(`[TriggerManager] initialDelayMs must be a non-negative number, got ${initialDelayMs}`);
+    }
+    const retryDelayMs = options.retryDelayMs ?? TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS;
+    if (!Number.isFinite(retryDelayMs) || retryDelayMs < 0) {
+        throw new Error(`[TriggerManager] retryDelayMs must be a non-negative number, got ${retryDelayMs}`);
+    }
+    if (options.timeoutMs != null) {
+        if (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 1) {
+            throw new Error(`[TriggerManager] timeoutMs must be a positive number when set, got ${options.timeoutMs}`);
+        }
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function invokeRunnerFn(fn, ctx, timeoutMs) {
+    if (timeoutMs == null) {
+        await fn(ctx);
+        return;
+    }
+    let timeoutHandle;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+            reject(new Error(`Runner timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    try {
+        await Promise.race([Promise.resolve(fn(ctx)), timeoutPromise]);
+    }
+    finally {
+        if (timeoutHandle != null) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+}
+/** In-process registry and tick loop for {@link TriggerNode}. */
+const TriggerManager = {
+    registerRunner(options) {
+        if (registrationClosed) {
+            throw new Error("[TriggerManager] Registration closed — call registerRunner before TriggerNode.start()");
+        }
+        const key = normalizeRunnerKey(options.key);
+        validateRunnerOptions(options);
+        if (typeof options.fn !== "function") {
+            throw new Error(`[TriggerManager] fn must be a function (runner key: ${key})`);
+        }
+        if (runnerRegistry.has(key)) {
+            throw new Error(`[TriggerManager] Duplicate runner key: ${key}`);
+        }
+        const now = Date.now();
+        runnerRegistry.set(key, {
+            key,
+            intervalMs: options.intervalMs,
+            fn: options.fn,
+            retryCount: options.retryCount ?? TRIGGER_RUNNER_DEFAULT_RETRY_COUNT,
+            retryDelayMs: options.retryDelayMs ?? TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS,
+            timeoutMs: options.timeoutMs,
+            nextRunAt: now + (options.initialDelayMs ?? 0),
+            running: false,
+        });
+    },
+    hasRunner(key) {
+        const normalized = tryNormalizeRunnerKey(key);
+        return normalized != null && runnerRegistry.has(normalized);
+    },
+    unregisterRunner(key) {
+        const normalized = tryNormalizeRunnerKey(key);
+        if (normalized == null) {
+            return false;
+        }
+        const runner = runnerRegistry.get(normalized);
+        if (runner == null) {
+            return false;
+        }
+        if (runner.running) {
+            throw new Error(`[TriggerManager] Cannot unregister running runner: ${normalized}`);
+        }
+        return runnerRegistry.delete(normalized);
+    },
+    getRunnerKeys() {
+        return [...runnerRegistry.keys()];
+    },
+    getRunnersBelowLoopInterval() {
+        return [...runnerRegistry.values()]
+            .filter((runner) => runner.intervalMs < TRIGGER_LOOP_INTERVAL_MS)
+            .map((runner) => ({ key: runner.key, intervalMs: runner.intervalMs }));
+    },
+    /** Called by TriggerNode during bootstrap — blocks further registerRunner calls. */
+    closeRegistration() {
+        registrationClosed = true;
+    },
+    /** Re-open registration (tests only). */
+    _resetRegistrationForTests() {
+        registrationClosed = false;
+    },
+    /**
+     * Remove all runners. Throws if any runner is still executing.
+     * Wait for in-flight ticks to finish before calling in tests.
+     */
+    clearRunners() {
+        for (const runner of runnerRegistry.values()) {
+            if (runner.running) {
+                throw new Error(`[TriggerManager] Cannot clearRunners while runner is running: ${runner.key}`);
+            }
+        }
+        runnerRegistry.clear();
+        registrationClosed = false;
+    },
+    async tick(ctx) {
+        const { loopTraceId, nodeId } = ctx;
+        const loopScope = createScope({ module: "tickRunners", traceId: loopTraceId, labels: { nodeId } });
+        const logger = createLogger({ scope: loopScope });
+        const now = Date.now();
+        const runners = [...runnerRegistry.values()];
+        if (runners.length === 0) {
+            logger.debug("無 runner 可調度", { topic: LOG_TOPIC_TRIGGER });
+            return;
+        }
+        // Overlap: if fn is still running when due, skip that tick (no catch-up / backlog).
+        // Safe while intervals are large; missed ticks increase if fn duration exceeds intervalMs.
+        const dueRunners = runners.filter((runner) => !runner.running && now >= runner.nextRunAt);
+        if (dueRunners.length === 0) {
+            logger.debug("本輪無到期 runner", { topic: LOG_TOPIC_TRIGGER });
+            return;
+        }
+        logger.debug("調度到期 runner", {
+            topic: LOG_TOPIC_TRIGGER,
+            data: { due: dueRunners.map((r) => r.key) },
+        });
+        const results = await Promise.all(dueRunners.map((runner) => runRunner(ctx, runner)));
+        const executed = results.filter(Boolean).length;
+        if (executed > 0) {
+            logger.info("Runner 調度完成", {
+                topic: LOG_TOPIC_TRIGGER,
+                data: { due: dueRunners.length, executed },
+            });
+        }
+        else {
+            logger.warn("本輪到期 runner 均未成功", {
+                topic: LOG_TOPIC_TRIGGER,
+                data: {
+                    due: dueRunners.length,
+                    runnerKeys: dueRunners.map((r) => r.key),
+                },
+            });
+        }
+    },
+};
+async function runRunner(ctx, runner) {
+    const { loopTraceId, nodeId } = ctx;
+    if (runner.running) {
+        return false;
+    }
+    runner.running = true;
+    const runnerLogger = createLogger({
+        scope: withModule(createScope({ module: "runRunner", traceId: loopTraceId, labels: { nodeId, runnerKey: runner.key } }), runner.key),
+    });
+    const maxAttempts = 1 + runner.retryCount;
+    let succeeded = false;
+    try {
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                runnerLogger.info("Runner 觸發", {
+                    topic: LOG_TOPIC_TRIGGER,
+                    data: { attempt, maxAttempts },
+                });
+                await invokeRunnerFn(runner.fn, {
+                    loopTraceId,
+                    nodeId,
+                    runnerKey: runner.key,
+                    logger: runnerLogger,
+                    attempt,
+                    maxAttempts,
+                }, runner.timeoutMs);
+                runnerLogger.success("Runner 完成", {
+                    topic: LOG_TOPIC_TRIGGER,
+                    data: { attempt, maxAttempts },
+                });
+                succeeded = true;
+                break;
+            }
+            catch (error) {
+                const message = getErrorMessage(error);
+                if (attempt < maxAttempts) {
+                    runnerLogger.warn("Runner 失敗，準備重試", {
+                        topic: LOG_TOPIC_TRIGGER,
+                        data: { attempt, maxAttempts, error: message },
+                    });
+                    if (runner.retryDelayMs > 0) {
+                        await delay(runner.retryDelayMs);
+                    }
+                }
+                else {
+                    runnerLogger.error("Runner 重試用盡仍失敗", {
+                        topic: LOG_TOPIC_TRIGGER,
+                        data: { attempt, maxAttempts, error: message },
+                    });
+                }
+            }
+        }
+    }
+    finally {
+        runner.running = false;
+        runner.nextRunAt = Date.now() + runner.intervalMs;
+    }
+    return succeeded;
+}
+
+/**
+ * Local interval scheduler node.
+ * Main loop: commands → heartbeat → {@link TriggerManager.tick}.
+ *
+ * Register runners via {@link TriggerManager.registerRunner} before {@link start}.
+ * Does not scan Supabase trigger rows — see `trigger.api.ts` for remote admin APIs.
+ *
+ * Deploy **one** TriggerNode per logical scheduler — multiple processes duplicate runner work.
+ */
+class TriggerNode extends BaseNodeRuntime {
+    requireRunners;
+    constructor(options) {
+        super("triggerNode");
+        this.requireRunners = options?.requireRunners ?? false;
+    }
+    getLoopIntervalMs() {
+        return TRIGGER_LOOP_INTERVAL_MS;
+    }
+    loopLoggerMinLevel() {
+        return LogLevel.WARN;
+    }
+    async onBeforeRegisterNode(logger) {
+        TriggerManager.closeRegistration();
+        const runnerKeys = TriggerManager.getRunnerKeys();
+        if (runnerKeys.length === 0) {
+            if (this.requireRunners) {
+                throw new Error("[TriggerNode] requireRunners is true but no runners are registered");
+            }
+            logger.warn("未注册任何 Trigger runner，主循環將空轉", {
+                topic: LOG_TOPIC_TRIGGER,
+            });
+            return;
+        }
+        for (const { key, intervalMs } of TriggerManager.getRunnersBelowLoopInterval()) {
+            logger.warn("Runner interval 小於主循環 tick 間隔，實際觸發精度受限", {
+                topic: LOG_TOPIC_TRIGGER,
+                data: {
+                    runnerKey: key,
+                    intervalMs,
+                    loopIntervalMs: TRIGGER_LOOP_INTERVAL_MS,
+                },
+            });
+        }
+        logger.success("Trigger 節點啟動", {
+            topic: LOG_TOPIC_TRIGGER,
+            data: { runnerKeys },
+        });
+    }
+    async runLoopSteps(ctx, heartbeatOk) {
+        if (!heartbeatOk) {
+            const logger = createLogger({
+                scope: createScope({
+                    module: `${this.runtimeModule}-runLoopSteps`,
+                    traceId: ctx.loopTraceId,
+                    labels: { nodeId: ctx.nodeId },
+                }),
+            });
+            logger.warn("心跳失敗，本輪跳過 runner", { topic: LOG_TOPIC_NODE });
+            return;
+        }
+        await TriggerManager.tick(ctx);
+    }
+}
+
+export { BaseNodeRuntime, CategoryCommand, CategoryRepo, CategoryTrigger, CommandType, LOG_TOPIC_TRIGGER, LogLevel, MAX_POLL_TARGET_LIST_SIZE, ManagedChildProcesses, NodeStatus, RepoManager, ResultCode, TASK_LOCAL_PACKAGE_CONFIG_FILENAME, TASK_REPO_SCRIPT_CATEGORY, TASK_REPO_USAGE, TASK_RUNNER_CONFIG_DIR, TASK_RUNNER_ROOT_CONFIG_FILENAME, TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH, TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH, TRIGGER_LOOP_INTERVAL_MS, TRIGGER_RUNNER_DEFAULT_RETRY_COUNT, TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS, TaskManager, TaskNode, TaskRepoValidation, TaskStatus, TaskStatusAction, TriggerManager, TriggerNode, TriggerStatus, buildNodeImportArgs, createLogger, createPathsExistCheck, createRequiredEnvCheck, createSupabaseReachableCheck, createTarget, generateResponse, getPollCommandList, getPollCommandListSchema, getPossibleTarget, getScanRemoteRepoValues, initSupabaseFromStandardEnv, isChildProcessRunning, isOptimisticLockResponse, loadEnvFiles, logManager, nodeBufferToArrayBuffer, patchChangeNodeStatus, patchChangeTaskStatus, patchClaimTask, patchNodeHeartBeat, patchStopNode, patchTriggerFired, patchTriggerFiredSchema, pollTargetList, postCommand, postCommandSchema, postRegisterNode, postTaskSchema, postTaskWithValidation, postTrigger, postTriggerSchema, publicBaseUrlFromEnv, readAndVerifySourceFile, readEnv, requireEnv, runReadinessChecks, scanEnabledTriggers, scanEnabledTriggersSchema, scanTargetList, sha256Hex, spawnTsxChild, supabase, updateTargetDetails, validateTaskRepoAndParams, validateWithSchema, waitForServiceReady };
+//# sourceMappingURL=node.js.map