target-supabase-sdk 0.1.9 → 0.2.0

package/src/repo/repo.script-loader.ts

@@ -3,7 +3,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 
-import { LoggerWithContext } from "../shared/log/log-manager";
+import { LoggerWithScope } from "../shared/log";
 import { resolvePathFromCwd, toFileImportHref } from "../shared/utils/config-path.utils";
 import { TaskRepoScriptRecord } from "../task/task-repo-context";
 import {
@@ -41,7 +41,7 @@ export async function loadRepoContextFromScript({
     script,
     taskTypeKey,
 }: {
-    logger: LoggerWithContext;
+    logger: LoggerWithScope;
     script: TaskRepoScriptRecord;
     taskTypeKey: string;
 }): Promise<LoadedRepoContext | null> {
@@ -49,7 +49,7 @@ export async function loadRepoContextFromScript({
     const cacheKey = `${taskTypeKey}@${loadKey}`;
     const cached = importedModuleCache.get(cacheKey);
     if (cached != null) {
-        logger.info("命中 Repo 脚本模块缓存", { topic: "repo", context: { cacheKey } });
+        logger.info("命中 Repo 脚本模块缓存", { topic: "repo", data: { cacheKey } });
         return cached;
     }
 
@@ -58,16 +58,16 @@ export async function loadRepoContextFromScript({
     try {
         let moduleExports: unknown;
         if (source != null && source.trim() !== "") {
-            logger.info("从 source 动态加载 Repo 脚本", { topic: "repo", context: { scriptId: script.id } });
+            logger.info("从 source 动态加载 Repo 脚本", { topic: "repo", data: { scriptId: script.id } });
             moduleExports = await importFromSource(source, cacheKey);
         } else if (modulePath != null && modulePath.trim() !== "") {
             logger.info("从 modulePath 动态加载 Repo 脚本", {
                 topic: "repo",
-                context: { scriptId: script.id, modulePath },
+                data: { scriptId: script.id, modulePath },
             });
             moduleExports = await importFromFilePath(modulePath);
         } else {
-            logger.warn("脚本缺少 source 或 modulePath", { topic: "repo", context: { scriptId: script.id } });
+            logger.warn("脚本缺少 source 或 modulePath", { topic: "repo", data: { scriptId: script.id } });
             return null;
         }
 
@@ -75,7 +75,7 @@ export async function loadRepoContextFromScript({
         if (context == null) {
             logger.warn("脚本模块未导出合法的 TaskRepoContext", {
                 topic: "repo",
-                context: { scriptId: script.id, exportName: exportName ?? "default" },
+                data: { scriptId: script.id, exportName: exportName ?? "default" },
             });
             return null;
         }
@@ -86,7 +86,7 @@ export async function loadRepoContextFromScript({
     } catch (error) {
         logger.error("动态加载 Repo 脚本失败", {
             topic: "repo",
-            context: { scriptId: script.id, error: error instanceof Error ? error.message : error },
+            data: { scriptId: script.id, error: error instanceof Error ? error.message : error },
         });
         return null;
     }
@@ -98,7 +98,7 @@ export async function loadRepoContextFromUrl({
     taskTypeKey,
     exportName,
 }: {
-    logger: LoggerWithContext;
+    logger: LoggerWithScope;
     url: string;
     taskTypeKey: string;
     exportName?: string;
@@ -107,18 +107,18 @@ export async function loadRepoContextFromUrl({
     const cacheKey = `${taskTypeKey}@url:${href}`;
     const cached = importedModuleCache.get(cacheKey);
     if (cached != null) {
-        logger.info("命中 Repo URL 模块缓存", { topic: "repo", context: { cacheKey } });
+        logger.info("命中 Repo URL 模块缓存", { topic: "repo", data: { cacheKey } });
         return cached;
     }
 
     try {
-        logger.info("从 Repo URL 动态加载脚本", { topic: "repo", context: { url, href } });
+        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",
-                context: { url, exportName: exportName ?? "default" },
+                data: { url, exportName: exportName ?? "default" },
             });
             return null;
         }
@@ -128,7 +128,7 @@ export async function loadRepoContextFromUrl({
     } catch (error) {
         logger.error("从 Repo URL 动态加载失败", {
             topic: "repo",
-            context: { url, error: error instanceof Error ? error.message : error },
+            data: { url, error: error instanceof Error ? error.message : error },
         });
         return null;
     }

package/src/shared/log/create-api-logger.ts

@@ -1,25 +1,36 @@
-import { logManager, type LogContext, type LoggerWithContext } from "./log-manager";
+import { logManager, type LoggerWithScope } from "./log-manager";
+import { normalizeScope, type LogScope, type LogScopePatch } from "./log-scope";
 
 /**
  * Options for {@link createApiLogger}.
  *
- * - **Core:** optional `traceId` (generated when omitted)
- * - **Business:** any other {@link LogContext} field (e.g. `nodeId`)
+ * - **Trace:** optional `traceId` / `traceParentId` (generated root when traceId omitted)
+ * - **Labels:** optional `labels` (e.g. `{ nodeId }`)
  */
 export type CreateApiLoggerOptions = {
     traceId?: string;
-} & Partial<Omit<LogContext, "module" | "traceId">>;
+    traceParentId?: string | null;
+    labels?: Record<string, string>;
+} & Partial<Omit<LogScope, "module" | "traceId" | "traceParentId" | "labels">>;
 
 /**
  * Logger for one SDK API invocation.
  *
- * Binds required `module` + optional caller `traceId`; business fields (e.g. `nodeId`) are optional.
+ * Binds `module` + normalized {@link LogScope}.
  */
-export function createApiLogger(module: string, options?: CreateApiLoggerOptions): LoggerWithContext {
-    const { traceId, ...businessFields } = options ?? {};
-    return logManager.withContext({
-        module,
-        traceId: traceId ?? logManager.generateTraceId(),
-        ...businessFields,
-    }).logger;
+export function createApiLogger(module: string, options?: CreateApiLoggerOptions): LoggerWithScope {
+    const { traceId, traceParentId, labels, ...rest } = options ?? {};
+    const scope = normalizeScope(
+        {
+            module,
+            traceId,
+            traceParentId: traceParentId ?? null,
+            labels,
+            ...rest,
+        },
+        { generateTraceId: true }
+    );
+    return logManager.withScope(scope).logger;
 }
+
+export type { LogScopePatch };

package/src/shared/log/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Log domain public API — curated re-exports only.
+ */
+
+// log-manager
+export { logManager, LogManager, LogLevel } from "./log-manager";
+export type { LogEntry, LogOptions, LoggerWithScope, LogRestParams } from "./log-manager";
+
+// create-api-logger
+export { createApiLogger } from "./create-api-logger";
+export type { CreateApiLoggerOptions } from "./create-api-logger";
+
+// log-scope
+export {
+    applyScopePatch,
+    createChildScope,
+    createRootScope,
+    formatScopeLabels,
+    normalizeScope,
+    resolveLogData,
+    withModule,
+} from "./log-scope";
+export type { LogScope, LogScopeInput, LogScopePatch, CreateRootScopeInput, CreateChildScopeInput } from "./log-scope";

package/src/shared/log/log-manager.ts

@@ -1,5 +1,12 @@
 import { isDevEnvironment } from "../../core.utils";
 import { generateUniqueId } from "../utils/id.utils";
+import {
+    applyScopePatch,
+    formatScopeLabels,
+    resolveLogData,
+    type LogScope,
+    type LogScopePatch,
+} from "./log-scope";
 
 /**
  * Log severity and semantics (low → high). `minLevel` filters by {@link LOG_LEVEL_RANK}.
@@ -31,44 +38,32 @@ const LOG_LEVEL_RANK: Record<LogLevel, number> = {
     [LogLevel.CRITICAL]: 5,
 };
 
-interface LogEntry {
+interface LogEntry extends LogScope {
     timestamp: number;
     level: LogLevel;
-    /** Tell people what happened, but more structured */
     message: string;
-    /** Category of a kind of log */
     topic: string | null;
-    /** Where the log comes from */
-    module: string;
-    /** Specific process — correlates one logical chain (loop, request). */
-    traceId: string;
-    /** Worker node id when the log is node-scoped; omit for scheduler / admin / API-only paths. */
-    nodeId?: string;
     extra?: string;
-    context?: unknown;
+    /** Per-line structured business payload. */
+    data?: unknown;
 }
 
-interface LogContext {
-    module: LogEntry["module"];
-    traceId: LogEntry["traceId"];
-    nodeId?: LogEntry["nodeId"];
-}
+type LogRestParams = {
+    topic?: LogEntry["topic"];
+    extra?: LogEntry["extra"];
+    data?: unknown;
+};
 
-type LogRestParams = Omit<LogParams, "message">;
+type LogParams = { message: LogEntry["message"] } & LogRestParams;
 
-interface LogEntryPayload {
+interface LogEntryPayload extends LogScope {
     message: LogEntry["message"];
     topic?: LogEntry["topic"];
     extra?: LogEntry["extra"];
-    context?: LogEntry["context"];
+    data?: LogEntry["data"];
     level: LogEntry["level"];
-    module: LogEntry["module"];
-    traceId: LogEntry["traceId"];
-    nodeId?: LogEntry["nodeId"];
 }
 
-type LogParams = Pick<LogEntryPayload, "message" | "topic" | "extra" | "context">;
-
 interface LogOptions {
     defaultTopic: LogEntry["topic"];
     formatTimestamp: boolean;
@@ -89,28 +84,24 @@ const DEFAULT_OPTIONS: LogOptions = {
     minLevel: isDevEnvironment() ? LogLevel.DEBUG : LogLevel.INFO,
 };
 
-interface LoggerWithContext {
-    /** Rank 0 — diagnostic detail; dev/troubleshooting only. */
+interface LoggerWithScope {
     debug: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    /** Rank 1 — normal operational flow. */
     info: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    /** Rank 2 — positive milestone (semantic INFO, not higher severity). */
     success: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    /** Rank 3 — recoverable anomaly; system continues. */
     warn: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    /** Rank 4 — a concrete operation failed; needs investigation. */
     error: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    /** Rank 5 — invariant / design / integrity breach; escalate immediately. */
     critical: (message: LogParams["message"], restParams?: LogRestParams) => void;
-    /** Merge partial fields into this logger's bound context (e.g. nodeId after register). */
-    resetContext: (fields: Partial<LogContext>) => void;
+    /** Merge partial fields into this logger's bound scope. */
+    resetScope: (fields: LogScopePatch) => void;
+    /** @deprecated use {@link LoggerWithScope.resetScope} */
+    resetContext: (fields: LogScopePatch) => void;
 }
 
 function mergeLogOptions(options?: Partial<LogOptions>): LogOptions {
     return { ...DEFAULT_OPTIONS, ...options };
 }
 
-function formatContextValue(value: unknown): string {
+function formatDataValue(value: unknown): string {
     if (value === undefined) {
         return "";
     }
@@ -124,16 +115,19 @@ function formatContextValue(value: unknown): string {
     }
 }
 
-function validateLogContext(logContext: LogContext): void {
+function validateLogScope(logScope: LogScope): void {
     const missing: string[] = [];
-    if (!logContext.module?.trim()) {
+    if (!logScope.module?.trim()) {
         missing.push("module");
     }
-    if (!logContext.traceId?.trim()) {
+    if (!logScope.traceId?.trim()) {
         missing.push("traceId");
     }
+    if (logScope.traceParentId !== null && typeof logScope.traceParentId !== "string") {
+        missing.push("traceParentId");
+    }
     if (missing.length > 0) {
-        console.warn(`[LogManager] LogContext missing or empty: ${missing.join(", ")}`, logContext);
+        console.warn(`[LogManager] LogScope missing or invalid: ${missing.join(", ")}`, logScope);
     }
 }
 
@@ -183,16 +177,8 @@ class LogManager {
         return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[this.getMinLevel()];
     }
 
-    private createLogEntry({
-        level,
-        message,
-        topic,
-        module,
-        traceId,
-        nodeId,
-        extra,
-        context,
-    }: LogEntryPayload): LogEntry {
+    private createLogEntry(payload: LogEntryPayload): LogEntry {
+        const { level, message, topic, extra, data, module, traceId, traceParentId, labels } = payload;
         return {
             timestamp: Date.now(),
             level,
@@ -200,9 +186,10 @@ class LogManager {
             topic: topic === undefined ? this.options.defaultTopic : topic,
             module,
             traceId,
-            nodeId,
+            traceParentId,
+            labels,
             extra,
-            context,
+            data,
         };
     }
 
@@ -223,7 +210,7 @@ class LogManager {
 
         parts.push(this.formatLevelTag(entry));
         parts.push(
-            `traceId=${entry.traceId} nodeId=${entry.nodeId ?? "--"} module=${entry.module} topic=${entry.topic ?? "--"}`
+            `traceId=${entry.traceId} parent=${entry.traceParentId ?? "null"} labels=${formatScopeLabels(entry.labels)} module=${entry.module} topic=${entry.topic ?? "--"}`
         );
 
         if (this.options.formatPrefix) {
@@ -238,9 +225,9 @@ class LogManager {
             parts.push(`| extra=${entry.extra}`);
         }
 
-        const contextText = formatContextValue(entry.context);
-        if (contextText) {
-            parts.push(`| context=${contextText}`);
+        const dataText = formatDataValue(entry.data);
+        if (dataText) {
+            parts.push(`| data=${dataText}`);
         }
 
         return parts.join(" ");
@@ -260,21 +247,23 @@ class LogManager {
         }
     }
 
-    private log(
-        level: LogLevel,
-        message: LogParams["message"],
-        logContext: LogContext,
-        restParams?: LogRestParams
-    ) {
+    private log(level: LogLevel, message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
         if (!this.shouldLog(level)) {
             return;
         }
 
-        validateLogContext(logContext);
+        validateLogScope(logScope);
 
-        const { topic, extra, context } = restParams ?? {};
-        const { module, traceId, nodeId } = logContext;
-        const entry = this.createLogEntry({ level, message, topic, extra, context, module, traceId, nodeId });
+        const { topic, extra } = restParams ?? {};
+        const data = resolveLogData(restParams);
+        const entry = this.createLogEntry({
+            level,
+            message,
+            topic,
+            extra,
+            data,
+            ...logScope,
+        });
 
         this.history.push(entry);
         if (this.history.length > this.options.maxHistoryLength) {
@@ -290,51 +279,57 @@ class LogManager {
         return generateUniqueId();
     }
 
-    public debug(message: LogParams["message"], logContext: LogContext, restParams?: LogRestParams) {
-        this.log(LogLevel.DEBUG, message, logContext, restParams);
+    public debug(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+        this.log(LogLevel.DEBUG, message, logScope, restParams);
     }
 
-    public info(message: LogParams["message"], logContext: LogContext, restParams?: LogRestParams) {
-        this.log(LogLevel.INFO, message, logContext, restParams);
+    public info(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+        this.log(LogLevel.INFO, message, logScope, restParams);
     }
 
-    public success(message: LogParams["message"], logContext: LogContext, restParams?: LogRestParams) {
-        this.log(LogLevel.SUCCESS, message, logContext, restParams);
+    public success(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+        this.log(LogLevel.SUCCESS, message, logScope, restParams);
     }
 
-    public warn(message: LogParams["message"], logContext: LogContext, restParams?: LogRestParams) {
-        this.log(LogLevel.WARN, message, logContext, restParams);
+    public warn(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+        this.log(LogLevel.WARN, message, logScope, restParams);
     }
 
-    public error(message: LogParams["message"], logContext: LogContext, restParams?: LogRestParams) {
-        this.log(LogLevel.ERROR, message, logContext, restParams);
+    public error(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+        this.log(LogLevel.ERROR, message, logScope, restParams);
     }
 
-    public critical(message: LogParams["message"], logContext: LogContext, restParams?: LogRestParams) {
-        this.log(LogLevel.CRITICAL, message, logContext, restParams);
+    public critical(message: LogParams["message"], logScope: LogScope, restParams?: LogRestParams) {
+        this.log(LogLevel.CRITICAL, message, logScope, restParams);
     }
 
-    public withContext(context: LogContext): { logger: LoggerWithContext; context: LogContext } {
-        const boundContext: LogContext = { ...context };
-
-        const logger: LoggerWithContext = {
-            debug: (message, restParams) => this.debug(message, boundContext, restParams),
-            info: (message, restParams) => this.info(message, boundContext, restParams),
-            success: (message, restParams) => this.success(message, boundContext, restParams),
-            warn: (message, restParams) => this.warn(message, boundContext, restParams),
-            error: (message, restParams) => this.error(message, boundContext, restParams),
-            critical: (message, restParams) => this.critical(message, boundContext, restParams),
+    public withScope(scope: LogScope): { logger: LoggerWithScope; scope: LogScope } {
+        const boundScope: LogScope = { ...scope, labels: scope.labels ? { ...scope.labels } : undefined };
+
+        const logger: LoggerWithScope = {
+            debug: (message, restParams) => this.debug(message, boundScope, restParams),
+            info: (message, restParams) => this.info(message, boundScope, restParams),
+            success: (message, restParams) => this.success(message, boundScope, restParams),
+            warn: (message, restParams) => this.warn(message, boundScope, restParams),
+            error: (message, restParams) => this.error(message, boundScope, restParams),
+            critical: (message, restParams) => this.critical(message, boundScope, restParams),
+            resetScope: (fields) => {
+                const next = applyScopePatch(boundScope, fields);
+                boundScope.module = next.module;
+                boundScope.traceId = next.traceId;
+                boundScope.traceParentId = next.traceParentId;
+                boundScope.labels = next.labels;
+            },
             resetContext: (fields) => {
-                Object.assign(boundContext, fields);
+                logger.resetScope(fields);
             },
         };
 
-        return { logger, context: boundContext };
+        return { logger, scope: boundScope };
     }
+
 }
 
 export const logManager = LogManager.getInstance();
 export { LogManager, LogLevel };
-export { createApiLogger } from "./create-api-logger";
-export type { CreateApiLoggerOptions } from "./create-api-logger";
-export type { LogOptions, LogEntry, LogContext, LoggerWithContext, LogRestParams };
+export type { LogOptions, LogEntry, LoggerWithScope, LogRestParams };

package/src/shared/log/log-scope.ts

@@ -0,0 +1,123 @@
+import { generateUniqueId } from "../utils/id.utils";
+
+/** Logger-bound scope: module + trace chain + optional labels. */
+export interface LogScope {
+    module: string;
+    traceId: string;
+    traceParentId: string | null;
+    labels?: Readonly<Record<string, string>>;
+}
+
+/** Partial update for {@link LogScope} / {@link applyScopePatch}. */
+export type LogScopePatch = Partial<Omit<LogScope, "labels">> & {
+    labels?: Record<string, string>;
+};
+
+export type LogScopeInput = LogScopePatch & Pick<LogScope, "module">;
+
+interface NormalizeScopeOptions {
+    /** When true and traceId is missing, generate a new id. */
+    generateTraceId?: boolean;
+}
+
+function mergeLabels(
+    base?: Readonly<Record<string, string>>,
+    patch?: Record<string, string>
+): Record<string, string> | undefined {
+    const merged: Record<string, string> = { ...base, ...patch };
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+
+/** Coerce partial input into a {@link LogScope}. */
+export function normalizeScope(input: LogScopeInput, options?: NormalizeScopeOptions): LogScope {
+    const generateTraceId = options?.generateTraceId ?? false;
+    const traceId = input.traceId?.trim() || (generateTraceId ? generateUniqueId() : "");
+    if (!traceId) {
+        throw new Error("[LogScope] traceId is required (or enable generateTraceId)");
+    }
+
+    return {
+        module: input.module,
+        traceId,
+        traceParentId: input.traceParentId ?? null,
+        labels: mergeLabels(undefined, input.labels),
+    };
+}
+
+/** Input for {@link createRootScope}. */
+export type CreateRootScopeInput = {
+    module: string;
+    traceId?: string;
+    labels?: Record<string, string>;
+    traceParentId?: string | null;
+};
+
+/** Root scope: traceParentId defaults to null. */
+export function createRootScope(input: CreateRootScopeInput): LogScope {
+    return normalizeScope(
+        {
+            module: input.module,
+            traceId: input.traceId,
+            traceParentId: input.traceParentId ?? null,
+            labels: input.labels,
+        },
+        { generateTraceId: true }
+    );
+}
+
+/** Input for {@link createChildScope}. */
+export type CreateChildScopeInput = {
+    module: string;
+    parent: LogScope;
+    traceId?: string;
+    traceParentId?: string | null;
+    labels?: Record<string, string>;
+};
+
+/** Child scope: parent link defaults to parent.traceId; labels merge with parent. */
+export function createChildScope(input: CreateChildScopeInput): LogScope {
+    const { module, parent, traceId, traceParentId, labels } = input;
+    return normalizeScope(
+        {
+            module,
+            traceId,
+            traceParentId: traceParentId ?? parent.traceId,
+            labels: mergeLabels(parent.labels, labels),
+        },
+        { generateTraceId: true }
+    );
+}
+
+/** Same trace chain, different module (e.g. prepareTask vs executeTask). */
+export function withModule(scope: LogScope, module: string): LogScope {
+    return { ...scope, module };
+}
+
+/** Merge patch into scope (labels deep-merge). */
+export function applyScopePatch(scope: LogScope, patch: LogScopePatch): LogScope {
+    return normalizeScope({
+        module: patch.module ?? scope.module,
+        traceId: patch.traceId ?? scope.traceId,
+        traceParentId: patch.traceParentId !== undefined ? patch.traceParentId : scope.traceParentId,
+        labels: mergeLabels(scope.labels, patch.labels),
+    });
+}
+export function formatScopeLabels(labels?: Readonly<Record<string, string>>): string {
+    if (labels == null || Object.keys(labels).length === 0) {
+        return "--";
+    }
+    return Object.entries(labels)
+        .map(([key, value]) => `${key}:${value}`)
+        .join(",");
+}
+
+/** Prefer `data`; fall back to deprecated `context` on log rest params. */
+export function resolveLogData(rest?: { data?: unknown; context?: unknown }): unknown | undefined {
+    if (rest?.data !== undefined) {
+        return rest.data;
+    }
+    if (rest?.context !== undefined) {
+        return rest.context;
+    }
+    return undefined;
+}

package/src/task/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Task domain public API — curated re-exports only.
+ * Internal modules (local-task-registry, task-repo-context, task.utils) stay private.
+ */
+
+// task.interface
+export {
+	CategoryTask,
+	ResultCode,
+	TaskStatus,
+	TaskStatusAction,
+} from "./task.interface";
+export type { Task, TaskDetails, TaskFlow } from "./task.interface";
+
+// task.api
+export {
+	patchChangeTaskStatus,
+	patchChangeTaskStatusSchema,
+	patchClaimTask,
+	patchClaimTaskSchema,
+	patchTaskProgress,
+	patchTaskProgressSchema,
+} from "./task.api";
+export type {
+	PatchChangeTaskStatusPayload,
+	PatchClaimTaskPayload,
+	PatchTaskProgressPayload,
+} from "./task.api";
+export { postTask, postTaskSchema } from "./task-post.api";
+export type { PostTaskPayload } from "./task-post.api";
+
+// task-manager
+export { TaskManager } from "./task-manager";
+export type {
+	PrepareTaskFailureReason,
+	PrepareTaskParams,
+	PrepareTaskResponse,
+	RegisterTasksOptions,
+	RegisterTasksResult,
+} from "./task-manager";
+
+// task-repo-validation
+export { TaskRepoValidation } from "./task-repo-validation";
+export type {
+	TaskRepoValidationFailureReason,
+	ValidateTaskRepoAndParamsInput,
+	ValidateTaskRepoAndParamsResult,
+} from "./task-repo-validation";