target-supabase-sdk 0.2.3 → 0.2.5

package/dist/node.js

@@ -1,18 +1,18 @@
 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-C7GJo_Nc.js';
-export { C as CLI_PROD_FLAG, S as SERVICE_ENV_PROFILE_ENV_KEY, d as SERVICE_ENV_PROFILE_PROD, e as createJsonFileStateStore, f as disableLogPersist, g as enableLogPersist, h as ensureLogPersistFromEnv, i as envBool, j as envInt, k as envMs, m as envNumber, n as envPort, o as envProfileFromProcess, q as getLogPersistStats, a as logPersistEnabledFromEnv, s as parseEnvFile, t as parseEnvLine, p as pinEnvProfileFromArgv, u as pollUntil, w as resolveDefaultEnvFiles, x as resolveLogPersistRegistryPath, r as resolveProjectRootByPackageName, y as resolveProjectRootFromModule, z as snapshotLogPersistReady, v as validateLogPersistPreloadEnv, A as waitForLogPersistReady } from './chunks/enable-log-persist-C7GJo_Nc.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 { M as MAX_POLL_TARGET_LIST_SIZE, G as validateWithSchema, f as createLogger, w as pollTargetList, i as generateResponse, g as createTarget, D as supabase, u as logManager, I as createScope, c as LogLevel, J as patchScope, A as scanTargetList, K as withModule, j as getPossibleTarget, r as isOptimisticLockResponse, E as updateTargetDetails } from './chunks/list.api-Ab9v8yOg.js';
+export { B as BaseValidator, C as CREATE_TARGET_ALREADY_EXISTS_MESSAGE, a as CategoryList, L as LOG_BATCH_LOADER_KEY, b as LOG_PERSIST_LOADER_KEY, d as MAX_TARGET_LIST_PAGE_SIZE, O as OPTIMISTIC_LOCK_ERROR_CODE, e as OPTIMISTIC_LOCK_FAILED_MESSAGE, P as PostListValidator, S as StatusCode, h as deleteTarget, k as getTarget, l as getTargetList, m as getTargetTotalCount, n as handleSupabaseError, o as isCreateTargetAlreadyExistsError, p as isDevEnvironment, q as isOptimisticLockError, s as logDev, t as logDevGroup, v as patchTarget, x as postListCreate, y as postLogListCreate, z as postTarget, F as validateWith } from './chunks/list.api-Ab9v8yOg.js';
+import { l as loadEnvFiles, b as readEnv, c as requireEnv, d as createJsonFileStateStore, a as logPersistEnabledFromEnv, e as disableLogPersist, g as getLogPersistStats, s as snapshotLogPersistReady, w as waitForLogPersistReady, f as ensureLogPersistFromEnv } from './chunks/enable-log-persist-BL2FaGQp.js';
+export { C as CLI_PROD_FLAG, S as SERVICE_ENV_PROFILE_ENV_KEY, h as SERVICE_ENV_PROFILE_PROD, i as enableLogPersist, j as envBool, k as envInt, m as envMs, n as envNumber, o as envPort, q as envProfileFromProcess, t as parseEnvFile, u as parseEnvLine, p as pinEnvProfileFromArgv, x as pollUntil, y as resolveDefaultEnvFiles, z as resolveLogPersistRegistryPath, r as resolveProjectRootByPackageName, A as resolveProjectRootFromModule, v as validateLogPersistPreloadEnv } from './chunks/enable-log-persist-BL2FaGQp.js';
+import { access, stat, readFile, mkdir, unlink, writeFile, readdir } from 'node:fs/promises';
+import { resolve, join, dirname, isAbsolute } from 'node:path';
+import { bd as sha256Hex, bi as getErrorMessage, aI as postRegisterNode, am as patchChangeNodeStatus, N as NodeStatus, ax as patchStopNode, au as patchNodeHeartBeat, E as EMPTY_REGISTRY_SLOT_RUNTIME_STATE, b3 as runRegistrySlotGuardCheck, aW as registrySlotRuntimePatchFromGuardResult, d as CategoryNode, L as evaluateBusyNodeLiveness, aw as patchServiceRuntime, l as ServiceRegistryError, v as claimServiceRegistrySlot, f as CategoryRepo, R as ResultCode, bj as LOG_TOPIC_TASK, n as TASK_REPO_USAGE, a4 as getScanRemoteRepoValues, aq as patchClaimTask, bk as CRITICAL_UNKNOWN_TASK_TRACE_ID, ao as patchChangeTaskStatus, p as TaskStatusAction, bl as toError, aQ as postTaskSchema, bm as createTaskRow, o as TaskStatus } from './chunks/word.interface-Mw7bTSqs.js';
+export { A as ApiMethod, C as CategoryConfig, a as CategoryExtraction, b as CategoryIdea, c as CategoryLink, e as CategoryParcel, g as CategoryService, h as CategoryTask, i as CategoryWord, D as DEFAULT_SYSTEM_REGISTRY_SEED_SLOTS, M as Market, P as POST_TASK_DEFAULT_MAX_ATTEMPTS, j as ParcelManager, k as PostLinkValidator, S as ServiceLifecycleStatus, m as ServiceSlotStatus, T as TARGET_SYSTEM_REGISTRY_KEY, q as apiDetailsSchema, r as assertRegistrySlotAvailable, s as assertRegistrySlotOwner, t as buildEmptyServiceSlots, u as buildSystemRegistryConfigDetails, w as classifyNetworkError, x as countTasksByType, y as createActiveServiceLifecycle, z as createClaimedRegistrySlotRuntimeState, B as createStorageProviderRegistry, F as createUploadTracker, G as decodeLogBatch, H as decodeLogBatchList, I as defaultL3ServiceDetails, J as deleteParcel, K as deleteParcelSchema, O as fetchBinaryWithRetry, Q as fetchWithRetry, U as fieldDefinitionSchema, V as flattenLogBatch, W as flattenLogBatches, X as formatNetworkError, Y as getApi, Z as getApiSchema, _ as getConfig, $ as getConfigSchema, a0 as getExtraction, a1 as getExtractionSchema, a2 as getParcel, a3 as getParcelSchema, a5 as getScanRemoteRepoValuesSchema, a6 as getService, a7 as getServiceSchema, a8 as getTargetSystemRegistry, a9 as getValueAtPath, aa as installChunkFetchRegistry, ab as isHttpUrl, ac as isLocalFilesystemPath, ad as isLogBatchList, ae as isLogEntry, af as isOpaqueChunkUrl, ag as isRetryableHttpStatus, ah as parcelDetailsSchema, ai as parseLogBatchMeta, aj as parseProviderPrefixedUrl, ak as parseServiceSlot, al as parseServiceSlots, an as patchChangeNodeStatusSchema, ap as patchChangeTaskStatusSchema, ar as patchClaimTaskSchema, as as patchExtractionObjects, at as patchExtractionObjectsSchema, av as patchNodeHeartBeatSchema, ay as patchStopNodeSchema, az as patchTaskProgress, aA as patchTaskProgressSchema, aB as postApi, aC as postApiSchema, aD as postExtraction, aE as postExtractionSchema, aF as postLinkCreate, aG as postParcel, aH as postParcelSchema, aJ as postRegisterNodeSchema, aK as postService, aL as postServiceInstance, aM as postServiceSchema, aN as postSystemRegistryConfig, aO as postSystemRegistryConfigSchema, aP as postTask, aR as postTaskWithRetry, aS as publishParcel, aT as registerProviderChunkResolver, aU as registerService, aV as registerServiceAtStartup, aX as releaseSystemRegistrySlots, aY as requestHasBody, aZ as resetSystemRegistryConfig, a_ as resetSystemRegistryConfigSchema, a$ as resolveActiveRegistryServiceId, b0 as resolveFetchUrl, b1 as restoreParcel, b2 as restoreParcelById, b4 as sanitizeFileName, b5 as sanitizeParcelFileName, b6 as scanExtractionList, b7 as scanExtractionListSchema, b8 as schemaDefinitionSchema, b9 as serviceDetailsSchema, ba as serviceLifecycleSchema, bb as serviceNodeSnapshotSchema, bc as serviceRuntimeSchema, be as summarizeTaskQueue, bf as systemRegistrySeedSlotSchema, bg as unregisterService, bh as unregisterServiceAtShutdown } from './chunks/word.interface-Mw7bTSqs.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 '@supabase/supabase-js';
 import 'node:fs';
 
 var CategoryCommand;
@@ -208,6 +208,7 @@ class BaseNodeRuntime {
     /** Log `nodeId` label while startup has not yet received an assigned id from Supabase. */
     static NODE_ID_PENDING_ASSIGNMENT = "pending-node-id";
     runtimeModule;
+    beforeProcessExitHook;
     _localNodeId = null;
     _isNodeIdLocked = false;
     isRunning;
@@ -230,13 +231,32 @@ class BaseNodeRuntime {
         this._localNodeId = value;
         this._isNodeIdLocked = true;
     }
-    constructor(runtimeModule) {
+    constructor(runtimeModule, options) {
         this.runtimeModule = runtimeModule;
+        this.beforeProcessExitHook = options?.beforeProcessExit ?? null;
         this.isRunning = false;
         this.loopCount = 0;
         this.startupTraceId = logManager.generateTraceId();
         this.startupScope = createScope({ module: runtimeModule, traceId: this.startupTraceId });
     }
+    async runBeforeProcessExit(logger) {
+        if (this.beforeProcessExitHook == null) {
+            return;
+        }
+        try {
+            await this.beforeProcessExitHook();
+        }
+        catch (error) {
+            logger.warn("beforeProcessExit 钩子失败（best-effort）", {
+                topic: LOG_TOPIC_PROCESS,
+                data: { error: getErrorMessage(error) },
+            });
+        }
+    }
+    async exitProcess(code, logger) {
+        await this.runBeforeProcessExit(logger);
+        process.exit(code);
+    }
     /** Hook: minimum log level for main-loop scoped loggers (heartbeat, batchCommand, iteration). */
     loopLoggerMinLevel() {
         return LogLevel.INFO;
@@ -443,7 +463,7 @@ class BaseNodeRuntime {
             return this.shutdownPromise;
         }
         this.isRunning = false;
-        this.shutdownPromise = this.runShutdown(options?.trigger).catch((error) => {
+        this.shutdownPromise = this.runShutdown(options?.trigger).catch(async (error) => {
             const logger = createLogger({
                 scope: patchScope({ scope: this.startupScope, patch: { labels: { nodeId: this.getLogNodeId() } } }),
             });
@@ -454,7 +474,7 @@ class BaseNodeRuntime {
                     error: getErrorMessage(error),
                 },
             });
-            process.exit(1);
+            await this.exitProcess(1, logger);
         });
         return this.shutdownPromise;
     }
@@ -468,7 +488,7 @@ class BaseNodeRuntime {
         });
         if (this.localNodeId == null) {
             logger.warn("本地節點未註冊，進程退出", { topic: LOG_TOPIC_NODE });
-            process.exit(0);
+            await this.exitProcess(0, logger);
             return;
         }
         logger.debug("正在登出節點", { topic: LOG_TOPIC_NODE, data: { nodeId: this.localNodeId } });
@@ -489,7 +509,7 @@ class BaseNodeRuntime {
             });
         }
         finally {
-            process.exit(0);
+            await this.exitProcess(0, logger);
         }
     }
     async heartbeat(ctx) {
@@ -535,7 +555,7 @@ class BaseNodeRuntime {
             return false;
         }
         this.consecutiveHeartbeatFailures = 0;
-        logger.success("心跳更新成功", {
+        logger.info("心跳更新成功", {
             topic: LOG_TOPIC_NODE,
             data: { lastHeartBeat: formatHeartbeat(lastHeartBeat) },
         });
@@ -660,14 +680,21 @@ class ManagedChildProcesses {
     projectRoot;
     preloadModules;
     graceMs;
+    defaultUseTsx;
     logger;
     byLabel = new Map();
+    criticalExitHandler = null;
+    suppressCriticalExit = false;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.preloadModules = options.preloadModules ?? [];
         this.graceMs = options.graceMs ?? 5_000;
+        this.defaultUseTsx = options.useTsx ?? true;
         this.logger = options.logger;
     }
+    setCriticalExitHandler(handler) {
+        this.criticalExitHandler = handler;
+    }
     get(label) {
         return this.byLabel.get(label) ?? null;
     }
@@ -680,7 +707,7 @@ class ManagedChildProcesses {
             .filter((entry) => isChildProcessRunning(entry[1]))
             .map(([label]) => label);
     }
-    spawn(label, entryScript) {
+    spawn(label, entryScript, spawnOptions) {
         const existing = this.getRunning(label);
         if (existing != null) {
             return { child: existing, created: false };
@@ -689,6 +716,8 @@ class ManagedChildProcesses {
             projectRoot: this.projectRoot,
             entryScript,
             preloadModules: this.preloadModules,
+            useTsx: spawnOptions?.useTsx ?? this.defaultUseTsx,
+            env: spawnOptions?.env != null ? { ...process.env, ...spawnOptions.env } : process.env,
         });
         child.on("exit", (code, signal) => {
             this.logger?.info("child exited", { topic: "process", data: { label, code, signal } });
@@ -696,6 +725,11 @@ class ManagedChildProcesses {
             if (current === child) {
                 this.byLabel.delete(label);
             }
+            if (!this.suppressCriticalExit &&
+                this.criticalExitHandler != null &&
+                this.criticalExitHandler.labels.includes(label)) {
+                this.criticalExitHandler.onCriticalExit(label, code, signal);
+            }
         });
         this.byLabel.set(label, child);
         this.logger?.info("child started", {
@@ -709,20 +743,26 @@ class ManagedChildProcesses {
         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
+        this.suppressCriticalExit = true;
+        try {
+            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
+                }
             }
         }
+        finally {
+            this.suppressCriticalExit = false;
+        }
     }
     stopChild(child) {
         return new Promise((resolvePromise) => {
@@ -737,6 +777,21 @@ class ManagedChildProcesses {
     }
 }
 
+const DEFAULT_PRELOAD_MODULES = ["./scripts/preload.mjs"];
+/**
+ * Standard L3 service child-process registry: node (not tsx), service preload, launcher logger.
+ * Each service keeps a singleton in `src/startup/child-processes.ts`.
+ */
+function createManagedChildProcesses(options) {
+    return new ManagedChildProcesses({
+        projectRoot: options.projectRoot,
+        preloadModules: options.preloadModules ?? DEFAULT_PRELOAD_MODULES,
+        useTsx: options.useTsx ?? false,
+        graceMs: options.graceMs,
+        logger: options.logger ?? createLogger({ module: "launcher" }),
+    });
+}
+
 /** Factory: all listed env keys must be non-empty. */
 function createRequiredEnvCheck(name, keys, options) {
     return () => {
@@ -837,1647 +892,2328 @@ async function waitForServiceReady(gate, options) {
     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);
-}
+const RUNTIME_STATE_SHARD_DIR = "runtime-state";
 /**
- * Resolve a path from a config file's directory.
+ * Resolve sharded runtime state layout from {@link CreateServiceRuntimeStateStoreOptions.filePath}.
  *
- * - 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`.
+ * | `filePath`              | Shard dir                         | Legacy        |
+ * |-------------------------|-----------------------------------|---------------|
+ * | `.../state.json`        | `.../runtime-state/`              | `state.json`  |
+ * | `.../runtime-state/`    | same directory                    | none          |
  */
-function resolvePathFromConfigFile(configFilePath, pathInConfig) {
-    const trimmed = pathInConfig.trim();
-    if (isAbsolute(trimmed)) {
-        return trimmed;
+function resolveRuntimeStatePaths(filePath) {
+    if (filePath.endsWith(".json")) {
+        return {
+            stateDir: join(dirname(filePath), RUNTIME_STATE_SHARD_DIR),
+            legacyFilePath: filePath,
+        };
     }
-    return resolve(getConfigFileDir(configFilePath), trimmed);
+    return {
+        stateDir: filePath,
+        legacyFilePath: null,
+    };
 }
-/**
- * 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);
+function runtimeStateShardPath(stateDir, sliceKey) {
+    return join(stateDir, `${sliceKey}.json`);
 }
-/**
- * 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);
+
+function isPlainObject(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
 }
-async function pathExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
+function mergeSlice(defaults, key, patchValue) {
+    const base = defaults[key];
+    if (isPlainObject(base) && isPlainObject(patchValue)) {
+        return { ...base, ...patchValue };
     }
+    return patchValue;
 }
 /**
- * Find the first existing file path: optional explicit path, else scan `candidatePaths` under `cwd`.
+ * JSON runtime state with **one file per top-level slice** (log-persist registry pattern).
+ * Eliminates cross-slice lost updates when guard/scheduler/worker write concurrently.
  */
-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;
+function createShardedJsonFileStateStore(options) {
+    const { defaultState, nestedKeys, updatedAtKey } = options;
+    const { stateDir, legacyFilePath } = resolveRuntimeStatePaths(options.filePath);
+    const shardStores = new Map();
+    function shardStore(sliceKey) {
+        const key = String(sliceKey);
+        let store = shardStores.get(key);
+        if (store == null) {
+            store = createJsonFileStateStore({
+                filePath: runtimeStateShardPath(stateDir, key),
+                defaultState: defaultState[sliceKey],
+            });
+            shardStores.set(key, store);
+        }
+        return store;
     }
-    for (const candidate of candidatePaths) {
-        const resolved = join(cwd, candidate);
-        if (await pathExists(resolved)) {
-            return resolved;
+    async function readUpdatedAtFromShardMtimes() {
+        let maxMtimeMs = 0;
+        for (const sliceKey of nestedKeys) {
+            try {
+                const shardStat = await stat(runtimeStateShardPath(stateDir, String(sliceKey)));
+                maxMtimeMs = Math.max(maxMtimeMs, shardStat.mtimeMs);
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+        if (maxMtimeMs <= 0) {
+            return defaultState[updatedAtKey];
         }
+        return new Date(maxMtimeMs).toISOString();
     }
-    return null;
-}
-/** `file://` href for Node dynamic `import()` of a local module. */
-function toFileImportHref(filePath) {
-    const trimmed = filePath.trim();
-    if (trimmed.includes("://")) {
-        return trimmed;
+    async function migrateLegacyMonolithicIfPresent() {
+        if (legacyFilePath == null) {
+            return;
+        }
+        let raw;
+        try {
+            raw = await readFile(legacyFilePath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            await unlink(legacyFilePath).catch(() => undefined);
+            return;
+        }
+        await mkdir(stateDir, { recursive: true });
+        for (const sliceKey of nestedKeys) {
+            const slice = parsed[sliceKey];
+            if (slice != null) {
+                await shardStore(sliceKey).write(slice);
+            }
+        }
+        await unlink(legacyFilePath).catch(() => undefined);
     }
-    return pathToFileURL(trimmed).href;
+    return {
+        async read() {
+            await mkdir(stateDir, { recursive: true });
+            await migrateLegacyMonolithicIfPresent();
+            const merged = { ...defaultState };
+            for (const sliceKey of nestedKeys) {
+                merged[sliceKey] = (await shardStore(sliceKey).read());
+            }
+            {
+                merged[updatedAtKey] = (await readUpdatedAtFromShardMtimes());
+            }
+            return merged;
+        },
+        async write(patch) {
+            await mkdir(stateDir, { recursive: true });
+            await migrateLegacyMonolithicIfPresent();
+            for (const sliceKey of nestedKeys) {
+                const patchSlice = patch[sliceKey];
+                if (patchSlice == null) {
+                    continue;
+                }
+                const current = await shardStore(sliceKey).read();
+                const nextSlice = mergeSlice(defaultState, sliceKey, {
+                    ...current,
+                    ...patchSlice,
+                });
+                await shardStore(sliceKey).write(nextSlice);
+            }
+            return this.read();
+        },
+        async reset() {
+            await mkdir(stateDir, { recursive: true });
+            for (const sliceKey of nestedKeys) {
+                await shardStore(sliceKey).reset();
+            }
+            if (legacyFilePath != null) {
+                await unlink(legacyFilePath).catch(() => undefined);
+            }
+            return this.read();
+        },
+    };
 }
-/** 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;
+
+const EPOCH_ISO = new Date(0).toISOString();
+function createDefaultServiceRuntimeState(options) {
+    const readiness = {
+        status: "pending",
+        checkedAt: null,
+        message: null,
+        checks: [],
+    };
+    const guard = {
+        nodeId: null,
+        lastCheckAt: null,
+        lastDecision: null,
+        lastSpawnAt: null,
+        spawnCount: 0,
+    };
+    const scheduler = {
+        lastTickAt: null,
+        lastPostedCount: 0,
+        lastFired: {},
+    };
+    const worker = {
+        pid: null,
+        spawnedAt: null,
+        ready: false,
+        registeredTasks: [],
+        readyAt: null,
+    };
+    return {
+        updatedAt: EPOCH_ISO,
+        readiness,
+        guard,
+        scheduler,
+        worker,
+        registry: { ...EMPTY_REGISTRY_SLOT_RUNTIME_STATE },
+        ...(options.extraDefaults ?? {}),
+    };
+}
+/** Sharded JSON runtime state (L3 blueprint) — one file per slice under `runtime-state/`. */
+function createServiceRuntimeStateStore(options) {
+    const defaultState = createDefaultServiceRuntimeState(options);
+    const nestedKeys = [
+        "readiness",
+        "guard",
+        "scheduler",
+        "worker",
+        "registry",
+        ...Object.keys(options.extraDefaults ?? {}),
+    ];
+    const store = createShardedJsonFileStateStore({
+        filePath: options.filePath,
+        defaultState,
+        nestedKeys,
+        updatedAtKey: "updatedAt",
+    });
+    return {
+        readRuntimeState: () => store.read(),
+        writeRuntimeState: (patch) => store.write(patch),
+        resetRuntimeStateForStartup: () => store.reset(),
+        finishRunnerTick: async ({ nowMs, lastFired, postedCount, extra }) => {
+            await store.write({
+                scheduler: {
+                    lastTickAt: new Date(nowMs).toISOString(),
+                    lastFired,
+                    ...(postedCount != null ? { lastPostedCount: postedCount } : {}),
+                },
+                ...extra,
+            });
+        },
+    };
 }
 
-function isTaskRepoContext(value) {
-    if (value == null || typeof value !== "object") {
-        return false;
+const LOG_TOPIC_TRIGGER = "trigger";
+/** Default main-loop interval for {@link TriggerNode} when `loopIntervalMs` is omitted (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");
     }
-    const record = value;
-    return typeof record.taskParamsValidator === "function" && typeof record.taskFn === "function";
+    return normalized;
 }
-/**
- * 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;
+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}`);
     }
-    taskParamsValidator ??= record.taskParamsValidator;
-    taskFn ??= record.taskFn;
-    if (typeof taskFn !== "function") {
-        return null;
+    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}`);
     }
-    if (typeof taskParamsValidator !== "function") {
-        taskParamsValidator = () => true;
+    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 fn = taskFn;
-    if (fn.displayName == null || fn.displayName === "") {
-        fn.displayName = taskTypeKey;
+    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 (fn.taskTypeKey == null || fn.taskTypeKey === "") {
-        fn.taskTypeKey = taskTypeKey;
+    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}`);
+        }
     }
-    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 delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
-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)}`;
+async function invokeRunnerFn(fn, ctx, timeoutMs) {
+    if (timeoutMs == null) {
+        await fn(ctx);
+        return;
     }
-    if (modulePath != null && modulePath !== "") {
-        return `path:${modulePath}`;
+    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]);
     }
-    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;
+    finally {
+        if (timeoutHandle != null) {
+            clearTimeout(timeoutHandle);
+        }
     }
-    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);
+/** 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()");
         }
-        else if (modulePath != null && modulePath.trim() !== "") {
-            logger.info("从 modulePath 动态加载 Repo 脚本", {
-                topic: "repo",
-                data: { scriptId: script.id, modulePath },
+        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(loopIntervalMs = TRIGGER_LOOP_INTERVAL_MS) {
+        return [...runnerRegistry.values()]
+            .filter((runner) => runner.intervalMs < loopIntervalMs)
+            .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 },
             });
-            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" },
+            logger.warn("本輪到期 runner 均未成功", {
+                topic: LOG_TOPIC_TRIGGER,
+                data: {
+                    due: dueRunners.length,
+                    runnerKeys: dueRunners.map((r) => r.key),
+                },
             });
-            return null;
         }
-        const loaded = { context, contentHash: loadKey };
-        importedModuleCache.set(cacheKey, loaded);
-        return loaded;
+    },
+};
+async function runRunner(ctx, runner) {
+    const { loopTraceId, nodeId } = ctx;
+    if (runner.running) {
+        return false;
     }
-    catch (error) {
-        logger.error("动态加载 Repo 脚本失败", {
-            topic: "repo",
-            data: { scriptId: script.id, error: error instanceof Error ? error.message : error },
+    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;
+}
+
+/**
+ * Run registry slot ownership check and optionally SIGTERM the parent main process.
+ * Used by guard / supervisor TriggerNode runners across L3 services.
+ */
+async function applyRegistrySlotGuardStep(input) {
+    const result = await runRegistrySlotGuardCheck({
+        serviceValue: input.serviceValue,
+        serviceId: input.serviceId,
+    });
+    const registryPatch = registrySlotRuntimePatchFromGuardResult(result, input.checkedAt);
+    if (result.shouldShutdown) {
+        input.logger.critical("Registry slot lost — shutting down service", {
+            topic: input.logTopic ?? "guard",
+            data: {
+                traceId: input.traceId,
+                serviceId: input.serviceId,
+                serviceValue: input.serviceValue,
+            },
+        });
+        process.kill(process.ppid, "SIGTERM");
+        return { continueTick: false, registryPatch };
+    }
+    if (result.error != null) {
+        input.logger.warn("Registry slot check failed (transient) — skipping enforcement this tick", {
+            topic: input.logTopic ?? "guard",
+            data: {
+                traceId: input.traceId,
+                serviceId: input.serviceId,
+                message: result.error,
+            },
         });
-        return null;
     }
+    return { continueTick: true, registryPatch };
 }
-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;
+
+let lastWorkerSpawnAt = 0;
+function getWorkerSpawnCooldownLastAt() {
+    return lastWorkerSpawnAt;
+}
+function markWorkerSpawned(at = Date.now()) {
+    lastWorkerSpawnAt = at;
+}
+
+/**
+ * One guard-runner tick: registry slot check, TaskNode liveness, optional worker
+ * respawn, Service runtime heartbeat rollup.
+ */
+async function runServiceGuardTick(input) {
+    const { serviceValue, serviceId, nodeId, loopTraceId, logger, logTopic = "guard", checkedAt, nowMs, taskNodeStaleMs, workerSpawnCooldownMs, maxNodes = 200, spawnWorker, getLastWorkerSpawnAt = getWorkerSpawnCooldownLastAt, markWorkerSpawned: markWorkerSpawnedAt = markWorkerSpawned, } = input;
+    const continueTick = true;
+    let registryPatch;
+    let decision = "idle";
+    if (serviceId != null) {
+        const guard = await applyRegistrySlotGuardStep({
+            serviceValue,
+            serviceId,
+            checkedAt,
+            logger,
+            logTopic,
+            traceId: loopTraceId,
+        });
+        registryPatch = guard.registryPatch;
+        if (!guard.continueTick) {
+            return { continueTick: false, decision: "slot_lost", nodes: [], registryPatch };
+        }
+        decision = "slot_ok";
+    }
+    const { data: nodes = [] } = await scanTargetList({
+        category: CategoryNode.NODE,
+        maxRows: maxNodes,
+    });
+    const liveness = evaluateBusyNodeLiveness(nodes, {
+        staleMs: taskNodeStaleMs,
+        now: nowMs,
+        excludeNodeId: nodeId,
+        onlyFreshCandidates: true,
+    });
+    const ageMs = liveness.freshest?.ageMs ?? Number.POSITIVE_INFINITY;
+    if (liveness.healthy) {
+        decision = "healthy";
+    }
+    else if (nowMs - getLastWorkerSpawnAt() < workerSpawnCooldownMs) {
+        decision = "spawn_cooldown";
+        logger.warn("TaskNode unavailable but spawn cooldown active", {
+            topic: logTopic,
+            data: {
+                traceId: loopTraceId,
+                ageMs,
+                staleMs: taskNodeStaleMs,
+                cooldownMs: workerSpawnCooldownMs,
+            },
+        });
+    }
+    else {
+        decision = "spawn_worker";
+        logger.warn("TaskNode stale — restarting worker", {
+            topic: logTopic,
+            data: {
+                traceId: loopTraceId,
+                peerWorkerCount: liveness.busyWorkerCount,
+                freshPeerCount: liveness.freshWorkerCount,
+                staleMs: taskNodeStaleMs,
+            },
+        });
+        await spawnWorker("guard:restart-unhealthy-tasknode");
+        markWorkerSpawnedAt(nowMs);
     }
     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;
+        await patchServiceRuntime({
+            serviceValue,
+            serviceId: serviceId ?? undefined,
+            nodes,
+            lastHeartBeat: nowMs,
+        });
     }
     catch (error) {
-        logger.error("从 Repo URL 动态加载失败", {
-            topic: "repo",
-            data: { url, error: error instanceof Error ? error.message : error },
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn("Failed to patch Service runtime rollup", {
+            topic: logTopic,
+            data: { traceId: loopTraceId, message },
         });
-        return null;
     }
-}
-/** Clear in-memory imported module cache (tests / hot reload). */
-function clearRepoScriptModuleCache() {
-    importedModuleCache.clear();
+    return { continueTick, decision, nodes, registryPatch };
 }
 
-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 },
-        ],
+/** Default TriggerManager runner key for {@link registerServiceGuardRunner}. */
+const SERVICE_GUARD_RUNNER_KEY = "service-guard";
+
+async function runServiceGuardRunner(ctx, options) {
+    const { loopTraceId, nodeId, logger } = ctx;
+    const nowMs = options.now?.() ?? Date.now();
+    const checkedAt = new Date(nowMs).toISOString();
+    const serviceId = await options.getServiceId();
+    const result = await runServiceGuardTick({
+        serviceValue: options.serviceValue,
+        serviceId,
+        nodeId,
+        loopTraceId,
+        logger,
+        logTopic: options.logTopic,
+        checkedAt,
+        nowMs,
+        taskNodeStaleMs: options.taskNodeStaleMs,
+        workerSpawnCooldownMs: options.workerSpawnCooldownMs,
+        maxNodes: options.maxNodes,
+        spawnWorker: options.spawnWorker,
     });
-    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;
+    if (result.registryPatch != null) {
+        await options.onRegistryPatch(result.registryPatch);
+    }
+    if (!result.continueTick) {
+        return;
+    }
+    await options.onGuardPatch({
+        nodeId,
+        lastCheckAt: checkedAt,
+        lastDecision: result.decision,
+    });
+    if (options.onDecision != null) {
+        await options.onDecision(result.decision);
     }
-    return (data ?? []);
 }
-async function loadLocalEntry(logger, entry, taskTypeKey) {
-    if (entry.kind === "context") {
-        return entry.context;
+/** Register the standard L3 guard runner (registry slot + TaskNode + Service runtime). */
+function registerServiceGuardRunner(options) {
+    TriggerManager.registerRunner({
+        key: options.runnerKey ?? SERVICE_GUARD_RUNNER_KEY,
+        intervalMs: options.intervalMs,
+        initialDelayMs: options.initialDelayMs,
+        fn: (ctx) => runServiceGuardRunner(ctx, options),
+    });
+}
+
+/** Run readiness checks, persist report via callback, fail-fast when not ok. */
+async function runReadinessGate(input) {
+    const { checks, onReport, logger, logTopic = "guard" } = input;
+    logger.info("Running readiness checks", { topic: logTopic });
+    const report = await runReadinessChecks(checks);
+    await onReport(report);
+    if (!report.ok) {
+        logger.error("Readiness checks failed", {
+            topic: logTopic,
+            data: { message: report.message, checks: report.checks },
+        });
+        throw new Error(report.message ?? "Readiness checks failed");
     }
-    const loaded = await loadRepoContextFromScript({
-        logger,
-        script: {
-            id: `local:${taskTypeKey}`,
-            value: taskTypeKey,
-            details: {
-                manifestVersion: 0,
-                modulePath: entry.modulePath,
-                exportName: entry.exportName,
-                isEntry: true,
-            },
-        },
-        taskTypeKey,
+    logger.debug("Readiness checks passed", {
+        topic: logTopic,
+        data: { checks: report.checks.map((check) => check.name) },
     });
-    return loaded?.context ?? null;
+    return report;
 }
-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" };
+
+/**
+ * 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;
+    loopIntervalMs;
+    constructor(options) {
+        super("triggerNode", { beforeProcessExit: options?.beforeProcessExit });
+        this.requireRunners = options?.requireRunners ?? false;
+        const loopIntervalMs = options?.loopIntervalMs ?? TRIGGER_LOOP_INTERVAL_MS;
+        if (!Number.isFinite(loopIntervalMs) || loopIntervalMs < 1) {
+            throw new Error(`[TriggerNode] loopIntervalMs must be a positive number, got ${loopIntervalMs}`);
+        }
+        this.loopIntervalMs = loopIntervalMs;
     }
-    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" };
+    getLoopIntervalMs() {
+        return this.loopIntervalMs;
     }
-    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 });
+    loopLoggerMinLevel() {
+        return LogLevel.WARN;
     }
-    if (loaded == null) {
-        const error = `無法從 Repo 加載 TaskRepoContext (hasUrl=${repoUrl !== ""}, scriptCount=${scripts.length})`;
-        logger.warn(error, {
-            topic: "repo",
-            data: { taskTypeKey, hasUrl: repoUrl !== "", scriptCount: scripts.length },
+    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(this.loopIntervalMs)) {
+            logger.warn("Runner interval 小於主循環 tick 間隔，實際觸發精度受限", {
+                topic: LOG_TOPIC_TRIGGER,
+                data: {
+                    runnerKey: key,
+                    intervalMs,
+                    loopIntervalMs: this.loopIntervalMs,
+                },
+            });
+        }
+        logger.success("Trigger 節點啟動", {
+            topic: LOG_TOPIC_TRIGGER,
+            data: { runnerKeys },
         });
-        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" };
+    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;
         }
-        const error = "本地 Repo 模組加載失敗或未導出有效的 TaskRepoContext";
-        logger.warn(error, { topic: "repo", data: { taskTypeKey } });
-        return { context: null, error, failureReason: "LOCAL_REPO_LOAD_FAILED" };
+        await TriggerManager.tick(ctx);
     }
-    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" };
+}
+
+/**
+ * L3 guard process TriggerNode: readiness gate, TaskNode worker spawn owner,
+ * and {@link registerServiceGuardRunner} tick (registry slot + liveness + runtime).
+ *
+ * Use {@link ServiceGuardNode.create} so the guard runner is registered before `start()`.
+ */
+class ServiceGuardNode extends TriggerNode {
+    options;
+    constructor(options) {
+        super({
+            requireRunners: true,
+            beforeProcessExit: options.beforeProcessExit,
+        });
+        this.options = options;
+    }
+    /** Register the guard runner and return a ready-to-start node. */
+    static create(options) {
+        registerServiceGuardRunner({
+            serviceValue: options.serviceValue,
+            logTopic: options.logTopic,
+            ...options.guardRunner,
+        });
+        return new ServiceGuardNode(options);
+    }
+    async onBeforeRegisterNode(nodeLogger) {
+        await runReadinessGate({
+            checks: this.options.readinessChecks,
+            onReport: this.options.onReadinessReport,
+            logger: nodeLogger,
+            logTopic: this.options.logTopic,
+        });
+        await super.onBeforeRegisterNode(nodeLogger);
+        nodeLogger.info("Spawning TaskNode worker (single spawn owner)", {
+            topic: this.options.logTopic ?? "guard",
+        });
+        await this.options.spawnWorker("guard:readiness-passed");
+        this.options.onWorkerSpawned?.();
     }
-    try {
-        const result = await loadRemoteRepoContext(logger, taskTypeKey);
-        if (result.context != null && isTaskRepoContext(result.context)) {
-            return { context: result.context, resolvedVia: "remote" };
+}
+
+const DEFAULT_CRITICAL_SUPERVISORS = ["guard", "supervisor"];
+function unwrapService(created) {
+    return typeof created === "object" && created != null && "service" in created ? created.service : created;
+}
+function createServiceHost(options) {
+    const logger = options.logger ?? createLogger({ module: "service-host" });
+    const logTopic = options.logTopic ?? "startup";
+    const criticalSupervisors = options.criticalSupervisors ?? DEFAULT_CRITICAL_SUPERVISORS;
+    let session = null;
+    let httpServer = null;
+    let shuttingDown = false;
+    async function shutdown(signal, exitCode = 0) {
+        if (shuttingDown) {
+            return;
         }
-        return {
-            context: null,
-            error: result.error ?? "遠程 Repo 上下文無效",
-            failureReason: result.failureReason ?? "REMOTE_REPO_LOAD_FAILED",
-        };
+        shuttingDown = true;
+        logger.info("shutting down", { topic: logTopic, data: { signal, exitCode } });
+        if (httpServer != null) {
+            await httpServer.close().catch(() => undefined);
+            httpServer = null;
+        }
+        if (options.onShutdown != null) {
+            await options.onShutdown(signal).catch(() => undefined);
+        }
+        if (session != null) {
+            await session.release();
+            session = null;
+        }
+        process.exit(exitCode);
     }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error("從 Supabase 加載 Repo 失敗", {
-            topic: "repo",
-            data: { taskTypeKey, error: message },
+    function requestShutdown(signal, exitCode = 0) {
+        void shutdown(signal, exitCode);
+    }
+    function installProcessHandlers() {
+        process.on("SIGINT", () => void shutdown("SIGINT"));
+        process.on("SIGTERM", () => void shutdown("SIGTERM"));
+        options.childProcesses?.setCriticalExitHandler({
+            labels: criticalSupervisors,
+            onCriticalExit: (label, code, signal) => {
+                if (shuttingDown) {
+                    return;
+                }
+                logger.critical("Critical supervisor exited — shutting down service", {
+                    topic: logTopic,
+                    data: { label, code, signal },
+                });
+                void shutdown("supervisor-exit", 1);
+            },
         });
-        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");
+    async function run() {
+        installProcessHandlers();
+        if (options.prepare != null) {
+            await options.prepare();
+        }
+        try {
+            session = await claimServiceRegistrySlot({
+                serviceValue: options.serviceValue,
+                createInstance: async () => unwrapService(await options.createInstance()),
+            });
+        }
+        catch (error) {
+            if (error instanceof ServiceRegistryError && error.code === "SERVICE_SLOTS_FULL") {
+                logger.critical("No EMPTY registry slot — refusing to start", {
+                    topic: logTopic,
+                    data: { serviceValue: options.serviceValue, code: error.code },
+                });
+                process.exit(1);
+            }
+            throw error;
+        }
+        if (options.onRegistryClaimed != null) {
+            await options.onRegistryClaimed({ service: session.service, session });
+        }
+        if (options.startSupervisors != null) {
+            await options.startSupervisors();
+        }
+        if (options.waitUntilReady != null) {
+            await options.waitUntilReady();
+        }
+        if (options.startServer != null) {
+            httpServer = await options.startServer();
+        }
     }
-    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");
+    async function runWithFatalHandling() {
+        try {
+            await run();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const code = error instanceof ServiceRegistryError ? error.code : undefined;
+            logger.error("fatal", { topic: logTopic, data: { message, code } });
+            if (httpServer != null) {
+                await httpServer.close().catch(() => undefined);
+                httpServer = null;
+            }
+            if (options.onShutdown != null) {
+                await options.onShutdown("fatal").catch(() => undefined);
+            }
+            if (session != null) {
+                await session.release().catch(() => undefined);
+                session = null;
+            }
+            process.exit(1);
+        }
     }
-    localRepoRegistry.set(taskTypeKey, { kind: "modulePath", modulePath, exportName });
-}
-function unregisterLocalRepo(taskTypeKey) {
-    localRepoRegistry.delete(taskTypeKey);
+    return { run: runWithFatalHandling, requestShutdown };
 }
-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}`);
+/**
+ * Single-process L3 entry (e.g. log-service): claim registry slot then run the service body.
+ * Registry release is the caller's responsibility inside `run` (e.g. TriggerNode `beforeProcessExit`).
+ */
+async function runSingleProcessService(options) {
+    const logger = options.logger ?? createLogger({ module: "single-process-service" });
+    const logTopic = options.logTopic ?? "startup";
+    if (options.prepare != null) {
+        await options.prepare();
     }
-    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}`);
+    let session = null;
+    try {
+        session = await claimServiceRegistrySlot({
+            serviceValue: options.serviceValue,
+            createInstance: options.createInstance,
+        });
     }
-    return { taskDir: taskDir.trim() };
-}
-function parseTaskPackageConfig(raw, configPath) {
-    if (raw == null || typeof raw !== "object") {
-        throw new Error(`Task config must export an object: ${configPath}`);
+    catch (error) {
+        if (error instanceof ServiceRegistryError && error.code === "SERVICE_SLOTS_FULL") {
+            logger.critical("No EMPTY registry slot — refusing to start", {
+                topic: logTopic,
+                data: { serviceValue: options.serviceValue, code: error.code },
+            });
+            process.exit(1);
+        }
+        throw error;
     }
-    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}`);
+    try {
+        await options.run({ service: session.service, session });
     }
-    if (typeof entry !== "string" || entry.trim() === "") {
-        throw new Error(`entry must be a non-empty string: ${configPath}`);
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error("fatal", { topic: logTopic, data: { message } });
+        await session.release().catch(() => undefined);
+        process.exit(1);
     }
-    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";
+
+/** 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);
 }
-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);
-        }
+/**
+ * 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;
     }
-    configMtims.sort((a, b) => a - b);
-    return `${rootConfigPath}:${rootStat.mtimeMs}:${tasksRoot}:${tasksRootStat.mtimeMs}:${configMtims.join(",")}`;
+    return resolve(getConfigFileDir(configFilePath), trimmed);
 }
-function canUseCachedBootstrap(fingerprint, forTaskTypeKey) {
-    if (bootstrapCache.fingerprint !== fingerprint || bootstrapCache.lastResult == null) {
-        return null;
-    }
-    if (forTaskTypeKey != null && forTaskTypeKey !== "") {
-        if (!RepoManager.hasLocalRepo(forTaskTypeKey)) {
-            return null;
-        }
+/**
+ * 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 { ...bootstrapCache.lastResult, cached: true };
+    return resolve(baseDir, trimmed);
 }
-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;
+/**
+ * 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;
     }
-    const result = {
-        registered: [],
-        skipped: [],
-        errors: [],
-    };
+    return resolve(cwd, trimmed);
+}
+async function pathExists(path) {
     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;
+        await access(path);
+        return true;
     }
-    catch (error) {
-        const failed = {
-            status: "failed",
-            message: error instanceof Error ? error.message : String(error),
-            ...result,
-        };
-        bootstrapCache = { fingerprint: null, lastResult: failed };
-        return failed;
+    catch {
+        return false;
     }
 }
 /**
- * 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"`).
+ * Find the first existing file path: optional explicit path, else scan `candidatePaths` under `cwd`.
  */
-async function bootstrapLocalTasks(options = {}) {
-    if (bootstrapInFlight != null) {
-        return bootstrapInFlight;
+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;
     }
-    bootstrapInFlight = runBootstrapScan(options).finally(() => {
-        bootstrapInFlight = null;
-    });
-    return bootstrapInFlight;
+    for (const candidate of candidatePaths) {
+        const resolved = join(cwd, candidate);
+        if (await pathExists(resolved)) {
+            return resolved;
+        }
+    }
+    return null;
 }
-/** Clear fingerprint cache (tests / hot-reload tooling). */
-function clearBootstrapLocalTasksCache() {
-    bootstrapCache = { fingerprint: null, lastResult: null };
-    bootstrapInFlight = 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;
 }
-function getRegisteredLocalTaskTypeKeys() {
-    return RepoManager.getRegisteredLocalTaskTypeKeys();
+/** 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;
+}
+const jsConfigCache = new Map();
+/**
+ * Import a JS config module, validate with a schema, cache by file mtime.
+ * For hot-reload, pass `{ force: true }` or rely on mtime change.
+ */
+async function loadCachedJsConfigModule(options) {
+    const { stat } = await import('node:fs/promises');
+    const { path, schema, force } = options;
+    const fileStat = await stat(path);
+    const cached = jsConfigCache.get(path);
+    if (!force && cached != null && cached.mtimeMs === fileStat.mtimeMs) {
+        return cached.data;
+    }
+    const raw = await importJsConfigModule(path);
+    const parsed = schema.safeParse(raw);
+    if (!parsed.success) {
+        throw new Error(`Invalid config ${path}: ${parsed.error.message}`);
+    }
+    jsConfigCache.set(path, { mtimeMs: fileStat.mtimeMs, data: parsed.data });
+    return parsed.data;
 }
 
-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 },
-        });
+function isTaskRepoContext(value) {
+    if (value == null || typeof value !== "object") {
         return false;
     }
-}
-function invalid(params) {
-    return { isValid: false, ...params };
+    const record = value;
+    return typeof record.taskParamsValidator === "function" && typeof record.taskFn === "function";
 }
 /**
- * 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.
+ * Normalize a dynamically imported module into {@link TaskRepoContext}.
+ * Supported shapes:
+ * - `export default { taskParamsValidator, taskFn }`
+ * - `export { taskParamsValidator, taskFn }`
+ * - `export default taskFn` (validator becomes `() => true`)
  */
-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,
-            },
-        });
+function normalizeRepoContextModule(moduleExports, taskTypeKey, exportName) {
+    if (moduleExports == null) {
+        return null;
     }
-    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",
-        });
+    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;
     }
-    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",
-        });
+    else if (typeof candidate === "object" && candidate != null) {
+        const ctx = candidate;
+        taskParamsValidator = ctx.taskParamsValidator;
+        taskFn = ctx.taskFn;
     }
-    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",
-        });
+    taskParamsValidator ??= record.taskParamsValidator;
+    taskFn ??= record.taskFn;
+    if (typeof taskFn !== "function") {
+        return null;
     }
-    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;
+    if (typeof taskParamsValidator !== "function") {
+        taskParamsValidator = () => true;
     }
-}
-/**
- * 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 fn = taskFn;
+    if (fn.displayName == null || fn.displayName === "") {
+        fn.displayName = taskTypeKey;
     }
-    const availableTaskList = [...new Set([...local.registered, ...remoteValues])];
-    if (availableTaskList.length === 0) {
-        throw new Error("任務註冊失敗：本地與遠程均無可用任務類型");
+    if (fn.taskTypeKey == null || fn.taskTypeKey === "") {
+        fn.taskTypeKey = taskTypeKey;
     }
-    logger.success("任務註冊完成", {
-        topic: LOG_TOPIC_TASK,
-        data: {
-            availableTaskList,
-            localRegistered: local.registered,
-            remoteValues,
-        },
-    });
     return {
-        availableTaskList,
-        local,
-        remote: { values: remoteValues },
-        includeRemote,
+        taskParamsValidator: taskParamsValidator,
+        taskFn: fn,
     };
 }
-/** 将 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,
-            },
-        });
+function pickEntryScript(scripts) {
+    if (scripts.length === 0) {
+        return null;
     }
-    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 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;
     }
-    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];
+    if (source != null && source !== "") {
+        return `source:${source.length}:${source.slice(0, 64)}`;
     }
-    constructor() {
-        super("taskNode");
+    if (modulePath != null && modulePath !== "") {
+        return `path:${modulePath}`;
     }
-    async onBeforeRegisterNode(logger) {
-        const { availableTaskList, includeRemote } = await TaskManager.registerTasks({ logger });
-        this._availableTaskList = availableTaskList;
-        this._includeRemote = includeRemote;
+    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;
     }
-    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);
+    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;
     }
-    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;
+    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);
         }
-        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,
-                },
+        else if (modulePath != null && modulePath.trim() !== "") {
+            logger.info("从 modulePath 动态加载 Repo 脚本", {
+                topic: "repo",
+                data: { scriptId: script.id, modulePath },
             });
-            return;
+            moduleExports = await importFromFilePath(modulePath);
         }
-        if (task == null) {
-            logger.debug("本輪無匹配的 TODO 任務", {
-                topic: LOG_TOPIC_TASK,
-                data: { availableTaskList },
+        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;
+            return null;
         }
-        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 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 },
         });
-        const prepareLogger = createLogger({ scope: withModule(taskScope, "prepareTask") });
-        const prepareResult = await TaskManager.prepareTask({
-            logger: prepareLogger,
-            task,
-            includeRemote: this._includeRemote,
+        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 },
         });
-        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,
-                },
+        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,
+};
+
+/**
+ * Bind service-specific log-persist registry settings (process list, paths, timeouts).
+ * Each L3 service exports one instance from `src/startup/log-persist.ts`.
+ */
+function createLogPersistCoordinator(options) {
+    const { service, registryFilePath, expectedProcesses, readyTimeoutMs } = options;
+    return {
+        isEnabled() {
+            return logPersistEnabledFromEnv();
+        },
+        getRegistryFilePath() {
+            return registryFilePath;
+        },
+        registerProcess(process) {
+            return ensureLogPersistFromEnv({
+                process,
+                service,
+                registryFilePath,
             });
-            await this.abortTaskRun({
-                logger: prepareLogger,
-                taskId: task.id,
-                nodeId,
-                traceId: taskTraceId,
+        },
+        waitForAllProcessesReady() {
+            return waitForLogPersistReady({
+                registryFilePath,
+                service,
+                expectedProcesses: [...expectedProcesses],
+                timeoutMs: readyTimeoutMs,
             });
-            return;
+        },
+        async snapshotProcessesReady() {
+            if (!logPersistEnabledFromEnv()) {
+                return null;
+            }
+            return snapshotLogPersistReady({
+                registryFilePath,
+                expectedProcesses: [...expectedProcesses],
+            });
+        },
+        getPersistStats() {
+            if (!logPersistEnabledFromEnv()) {
+                return null;
+            }
+            return getLogPersistStats();
+        },
+        async shutdownLogPersist() {
+            if (!logPersistEnabledFromEnv()) {
+                return;
+            }
+            await disableLogPersist();
+        },
+    };
+}
+
+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;
         }
-        logger.success("任務準備完成", {
-            topic: LOG_TOPIC_TASK,
+        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: {
-                taskId: task.id,
-                taskName: task.name,
-                taskTypeKey: task.value,
-                displayName: taskFn.displayName,
+                taskTypeKey,
+                step: "local_bootstrap",
+                status: bootstrap.status,
+                registered: bootstrap.registered,
+                cached: bootstrap.cached ?? false,
+                message: bootstrap.message,
             },
         });
-        const executeLogger = createLogger({ scope: withModule(taskScope, "executeTask") });
-        const onExecuteAbort = async (error) => {
-            executeLogger.critical("任務執行遇到未知錯誤，中止任務並 RESET 為 OPEN", {
+    }
+    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: {
-                    taskId: task.id,
-                    taskTypeKey: task.value,
-                    taskName: task.name,
-                    displayName: taskFn.displayName,
-                    error: getErrorMessage(error),
+                    registered: bootstrap.registered,
+                    skipped: bootstrap.skipped,
+                    errors: bootstrap.errors,
                 },
             });
-            await this.abortTaskRun({
-                logger: executeLogger,
-                taskId: task.id,
-                nodeId,
-                traceId: taskTraceId,
-            });
-        };
-        executeLogger.info("開始執行業務邏輯", {
+            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: { taskId: task.id, displayName: taskFn.displayName },
+            data: { usage: TASK_REPO_USAGE },
         });
-        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 { data, error: remoteError } = await getScanRemoteRepoValues({ usage: TASK_REPO_USAGE });
+        if (remoteError) {
+            throw new Error(remoteError.message);
         }
-        const duration = Date.now() - startTime;
-        executeLogger.info("業務邏輯執行結束", {
+        remoteValues = data ?? [];
+        logger.debug("遠程 Repo 查詢完成", {
             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,
+            data: { count: remoteValues.length, values: remoteValues },
         });
-        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 });
-        }
+    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, ctx) {
+    const run = async () => taskFn(taskParams, ctx);
+    return Object.assign(run, {
+        displayName: taskFn.displayName,
+        taskTypeKey: taskFn.taskTypeKey,
+    });
 }
-
 /**
- * Create a task row with publish-time Repo + params validation.
- * **Node entry only** — requires local Repo bootstrap and {@link TaskRepoValidation}.
+ * 將 Supabase 認領到的 Task 解析為可執行的 `ExecutableTaskFn`。
  *
- * @see target-supabase-sdk/node
+ * 流程：
+ * 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 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",
+const prepareTask = async ({ logger, task, includeRemote = true, bootstrapLocalOptions, }) => {
+    const fail = (params) => {
+        logger.warn(params.message, {
+            topic: LOG_TOPIC_TASK,
             data: {
-                taskTypeKey: value,
-                reason: validation.reason,
-                step: validation.step,
+                taskId: task.id,
+                taskTypeKey: task.value,
+                reason: params.reason,
+                step: params.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,
+        return {
+            isSuccess: false,
+            taskFn: null,
+            code: params.code,
+            message: params.message,
+            reason: params.reason,
+            step: params.step,
+        };
     };
-    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 },
+    const { id: taskId, name: taskName, value: taskTypeKey, details } = task;
+    logger.debug(`開始準備任務 ${taskName}-${taskTypeKey}`, {
+        topic: LOG_TOPIC_TASK,
+        data: { taskId, taskName, taskTypeKey },
     });
-    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,
-            }),
+    const { params: taskParams } = details;
+    if (!getRegisteredLocalTaskTypeKeys().includes(taskTypeKey)) {
+        const bootstrap = await bootstrapLocalTasks({
+            ...bootstrapLocalOptions,
+            forTaskTypeKey: taskTypeKey,
         });
-        logger.success("Trigger 觸發記錄已更新", {
-            topic: "trigger",
-            data: { triggerId, fireKey },
+        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,
+            },
         });
-        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 },
+    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,
         });
-        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);
+    const { repoContext } = validation;
+    logger.debug("Repo 上下文加載成功", {
+        topic: LOG_TOPIC_TASK,
+        data: {
+            taskTypeKey,
+            taskFnDisplayName: repoContext.taskFn.displayName,
+            step: "repo_load",
+        },
     });
-    try {
-        await Promise.race([Promise.resolve(fn(ctx)), timeoutPromise]);
+    const boundTaskFn = bindTaskFn(repoContext.taskFn, taskParams, {
+        taskId,
+        taskName,
+        taskTypeKey,
+        traceId: details.traceId ?? taskId,
+    });
+    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];
     }
-    finally {
-        if (timeoutHandle != null) {
-            clearTimeout(timeoutHandle);
-        }
+    constructor() {
+        super("taskNode");
     }
-}
-/** 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}`);
-            }
+    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;
         }
-        runnerRegistry.clear();
-        registrationClosed = false;
-    },
-    async tick(ctx) {
+        await this.runAsWorker(ctx);
+    }
+    async runAsWorker(ctx) {
         const { loopTraceId, nodeId } = ctx;
-        const loopScope = createScope({ module: "tickRunners", traceId: loopTraceId, labels: { nodeId } });
+        const loopScope = createScope({ module: "runAsWorker", 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 });
+        const availableTaskList = this.availableTaskList;
+        if (availableTaskList.length === 0) {
+            logger.warn("未配置可認領任務類型，跳過本輪", { topic: LOG_TOPIC_TASK });
             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 });
+        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;
         }
-        logger.debug("調度到期 runner", {
-            topic: LOG_TOPIC_TRIGGER,
-            data: { due: dueRunners.map((r) => r.key) },
+        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 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 },
+        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;
         }
-        else {
-            logger.warn("本輪到期 runner 均未成功", {
-                topic: LOG_TOPIC_TRIGGER,
+        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: {
-                    due: dueRunners.length,
-                    runnerKeys: dueRunners.map((r) => r.key),
+                    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();
         }
-    },
-};
-async function runRunner(ctx, runner) {
-    const { loopTraceId, nodeId } = ctx;
-    if (runner.running) {
-        return false;
+        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,
+            },
+        });
     }
-    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 },
-                    });
-                }
-            }
+    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;
     }
-    finally {
-        runner.running = false;
-        runner.nextRunAt = Date.now() + runner.intervalMs;
+    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 });
+        }
     }
-    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.
+ * Create a task row with publish-time Repo + params validation.
+ * **Node entry only** — requires local Repo bootstrap and {@link TaskRepoValidation}.
  *
- * Deploy **one** TriggerNode per logical scheduler — multiple processes duplicate runner work.
+ * @see target-supabase-sdk/node
  */
-class TriggerNode extends BaseNodeRuntime {
-    requireRunners;
-    constructor(options) {
-        super("triggerNode");
-        this.requireRunners = options?.requireRunners ?? false;
+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));
     }
-    getLoopIntervalMs() {
-        return TRIGGER_LOOP_INTERVAL_MS;
+    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);
     }
-    loopLoggerMinLevel() {
-        return LogLevel.WARN;
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return generateResponse.error(message);
     }
-    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 },
+});
+/** 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);
     }
-    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);
+    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);
     }
-}
+});
 
-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 };
+export { BaseNodeRuntime, CategoryCommand, CategoryNode, CategoryRepo, CategoryTrigger, CommandType, EMPTY_REGISTRY_SLOT_RUNTIME_STATE, LOG_TOPIC_TRIGGER, LogLevel, MAX_POLL_TARGET_LIST_SIZE, ManagedChildProcesses, NodeStatus, RepoManager, ResultCode, SERVICE_GUARD_RUNNER_KEY, ServiceGuardNode, ServiceRegistryError, 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, applyRegistrySlotGuardStep, buildNodeImportArgs, claimServiceRegistrySlot, createJsonFileStateStore, createLogPersistCoordinator, createLogger, createManagedChildProcesses, createPathsExistCheck, createRequiredEnvCheck, createServiceHost, createServiceRuntimeStateStore, createSupabaseReachableCheck, createTarget, disableLogPersist, ensureLogPersistFromEnv, evaluateBusyNodeLiveness, generateResponse, getConfigFileDir, getLogPersistStats, getPollCommandList, getPollCommandListSchema, getPossibleTarget, getScanRemoteRepoValues, getWorkerSpawnCooldownLastAt, importJsConfigModule, initSupabaseFromStandardEnv, isChildProcessRunning, isOptimisticLockResponse, loadCachedJsConfigModule, loadEnvFiles, logManager, logPersistEnabledFromEnv, markWorkerSpawned, nodeBufferToArrayBuffer, patchChangeNodeStatus, patchChangeTaskStatus, patchClaimTask, patchNodeHeartBeat, patchServiceRuntime, patchStopNode, patchTriggerFired, patchTriggerFiredSchema, pathExists, pollTargetList, postCommand, postCommandSchema, postRegisterNode, postTaskSchema, postTaskWithValidation, postTrigger, postTriggerSchema, publicBaseUrlFromEnv, readAndVerifySourceFile, readEnv, registerServiceGuardRunner, registrySlotRuntimePatchFromGuardResult, requireEnv, resolveFirstExistingPath, resolvePathFromBaseDir, resolvePathFromConfigFile, resolvePathFromCwd, runReadinessChecks, runReadinessGate, runRegistrySlotGuardCheck, runServiceGuardTick, runSingleProcessService, scanEnabledTriggers, scanEnabledTriggersSchema, scanTargetList, sha256Hex, snapshotLogPersistReady, spawnTsxChild, supabase, toFileImportHref, updateTargetDetails, validateTaskRepoAndParams, validateWithSchema, waitForLogPersistReady, waitForServiceReady };
 //# sourceMappingURL=node.js.map