substrate-ai 0.1.33 → 0.2.1

package/dist/git-utils-BtI5eNoN.js

@@ -0,0 +1,365 @@
+import { createLogger } from "./logger-C6n1g8uP.js";
+import { spawn } from "node:child_process";
+import * as path from "node:path";
+import { access, readdir } from "node:fs/promises";
+
+//#region src/modules/git-worktree/git-utils.ts
+const logger = createLogger("git-utils");
+const MIN_GIT_MAJOR = 2;
+const MIN_GIT_MINOR = 20;
+/**
+* Spawn a git subprocess with the given args.
+*
+* @param args    - Arguments to pass to git (e.g., ['worktree', 'add', ...])
+* @param options - Optional spawn options (cwd, env)
+* @returns       - Object with stdout, stderr, and exit code
+*/
+function spawnGit(args, options) {
+	return new Promise((resolve$1) => {
+		logger.debug({
+			args,
+			cwd: options?.cwd
+		}, "spawnGit");
+		const proc = spawn("git", args, {
+			cwd: options?.cwd,
+			env: options?.env ?? process.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		proc.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		proc.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		proc.on("close", (code) => {
+			resolve$1({
+				stdout: stdout.trim(),
+				stderr: stderr.trim(),
+				code: code ?? 1
+			});
+		});
+		proc.on("error", (err) => {
+			resolve$1({
+				stdout: "",
+				stderr: err.message,
+				code: 1
+			});
+		});
+	});
+}
+/**
+* Get the installed git version string.
+*
+* @returns Version string like "2.42.0"
+* @throws  Error if git is not installed or version cannot be parsed
+*/
+async function getGitVersion() {
+	const result = await spawnGit(["--version"]);
+	if (result.code !== 0) throw new Error(`git --version failed: ${result.stderr}`);
+	const match = /git version\s+(\d+\.\d+(?:\.\d+)?)/.exec(result.stdout);
+	if (match === null || match[1] === void 0) throw new Error(`Unable to parse git version from output: "${result.stdout}"`);
+	return match[1];
+}
+/**
+* Parse a git version string into major/minor/patch components.
+*
+* @param versionString - Version string like "2.42.0" or "2.20"
+* @returns             - Parsed version components
+*/
+function parseGitVersion(versionString) {
+	const parts = versionString.split(".").map(Number);
+	return {
+		major: parts[0] ?? 0,
+		minor: parts[1] ?? 0,
+		patch: parts[2] ?? 0
+	};
+}
+/**
+* Check if the given git version string is >= 2.20.0.
+*
+* @param version - Version string like "2.42.0"
+* @returns       - true if version >= 2.20.0
+*/
+function isGitVersionSupported(version) {
+	const { major, minor } = parseGitVersion(version);
+	if (major > MIN_GIT_MAJOR) return true;
+	if (major === MIN_GIT_MAJOR && minor >= MIN_GIT_MINOR) return true;
+	return false;
+}
+/**
+* Verify that git is installed and version >= 2.20.
+*
+* @throws Error with clear message if git is not installed or too old
+*/
+async function verifyGitVersion() {
+	let version;
+	try {
+		version = await getGitVersion();
+	} catch (err) {
+		throw new Error(`git is not installed or could not be executed. Please install git 2.20 or newer. Details: ${String(err)}`);
+	}
+	if (!isGitVersionSupported(version)) {
+		const { major, minor, patch } = parseGitVersion(version);
+		throw new Error(`Git version ${major}.${minor}.${patch} is too old. Substrate requires git 2.20 or newer. Please upgrade git: https://git-scm.com/downloads`);
+	}
+	logger.debug({ version }, "git version verified");
+}
+/**
+* Create a git worktree and its associated branch.
+*
+* Uses a single `git worktree add {worktreePath} -b {branchName} {baseBranch}`
+* command to create the worktree with a new branch in one step.
+*
+* @param projectRoot - Absolute path to the git repository root
+* @param taskId      - Task identifier (used in path derivation)
+* @param branchName  - Branch name to create (e.g., "substrate/task-abc123")
+* @param baseBranch  - Branch to base the worktree on (e.g., "main")
+* @returns           - Object with the worktreePath
+* @throws            - Error if git command fails
+*/
+async function createWorktree(projectRoot, taskId, branchName, baseBranch) {
+	const worktreePath = path.join(projectRoot, ".substrate-worktrees", taskId);
+	logger.debug({
+		projectRoot,
+		taskId,
+		branchName,
+		baseBranch,
+		worktreePath
+	}, "createWorktree");
+	const addResult = await spawnGit([
+		"worktree",
+		"add",
+		worktreePath,
+		"-b",
+		branchName,
+		baseBranch
+	], { cwd: projectRoot });
+	if (addResult.code !== 0) throw new Error(`git worktree add failed for task "${taskId}": ${addResult.stderr || addResult.stdout}`);
+	logger.info({
+		taskId,
+		branchName,
+		worktreePath
+	}, "Worktree created");
+	return { worktreePath };
+}
+/**
+* Remove a git worktree by path.
+*
+* Uses `git worktree remove --force` to handle unclean worktrees.
+*
+* @param worktreePath - Absolute path to the worktree directory
+* @param projectRoot  - Absolute path to the git repository root
+* @throws             - Error if git command fails
+*/
+async function removeWorktree(worktreePath, projectRoot) {
+	logger.debug({ worktreePath }, "removeWorktree");
+	const spawnOpts = {};
+	if (projectRoot !== void 0) spawnOpts.cwd = projectRoot;
+	const result = await spawnGit([
+		"worktree",
+		"remove",
+		"--force",
+		worktreePath
+	], spawnOpts);
+	if (result.code !== 0) throw new Error(`git worktree remove failed for "${worktreePath}": ${result.stderr || result.stdout}`);
+	logger.debug({ worktreePath }, "Worktree removed");
+}
+/**
+* Delete a git branch using `git branch -D`.
+*
+* @param branchName  - Branch name to delete (e.g., "substrate/task-abc123")
+* @param projectRoot - Absolute path to the git repository root
+* @returns           - true if branch was successfully deleted, false otherwise
+*/
+async function removeBranch(branchName, projectRoot) {
+	logger.debug({ branchName }, "removeBranch");
+	const spawnOpts = {};
+	if (projectRoot !== void 0) spawnOpts.cwd = projectRoot;
+	const result = await spawnGit([
+		"branch",
+		"-D",
+		branchName
+	], spawnOpts);
+	if (result.code !== 0) {
+		logger.warn({
+			branchName,
+			stderr: result.stderr
+		}, "git branch -D failed (may already be deleted)");
+		return false;
+	}
+	logger.debug({ branchName }, "Branch deleted");
+	return true;
+}
+/**
+* Scan the worktrees base directory and return paths of all found worktree directories.
+*
+* @param projectRoot   - Absolute path to the git repository root
+* @param baseDirectory - Relative directory name for worktrees (default: '.substrate-worktrees')
+* @returns             - Array of absolute worktree directory paths
+*/
+async function getOrphanedWorktrees(projectRoot, baseDirectory = ".substrate-worktrees") {
+	const worktreesDir = path.join(projectRoot, baseDirectory);
+	try {
+		await access(worktreesDir);
+	} catch {
+		return [];
+	}
+	let entries;
+	try {
+		entries = await readdir(worktreesDir, { withFileTypes: true });
+	} catch (err) {
+		logger.warn({
+			worktreesDir,
+			err
+		}, "getOrphanedWorktrees: failed to read directory");
+		return [];
+	}
+	return entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(worktreesDir, entry.name));
+}
+/**
+* Simulate a merge using git merge --no-commit --no-ff without committing.
+*
+* This runs in the target branch's working directory (the project root or
+* worktree path). The simulation must be aborted after checking conflicts
+* via abortMerge().
+*
+* @param branchName  - The source branch to simulate merging
+* @param cwd         - Working directory (must be on the target branch)
+* @returns           - true if merge would be clean, false if there are conflicts
+*/
+async function simulateMerge(branchName, cwd) {
+	logger.debug({
+		branchName,
+		cwd
+	}, "simulateMerge");
+	const result = await spawnGit([
+		"merge",
+		"--no-commit",
+		"--no-ff",
+		branchName
+	], { cwd });
+	if (result.code === 0) return true;
+	return false;
+}
+/**
+* Abort a merge in progress using git merge --abort.
+*
+* Should be called after simulateMerge() to clean up the merge state,
+* regardless of whether conflicts were found.
+*
+* @param cwd - Working directory (same as used for simulateMerge)
+*/
+async function abortMerge(cwd) {
+	logger.debug({ cwd }, "abortMerge");
+	const result = await spawnGit(["merge", "--abort"], { cwd });
+	if (result.code !== 0) logger.warn({
+		cwd,
+		stderr: result.stderr
+	}, "abortMerge: git merge --abort returned non-zero (may have been nothing to abort)");
+	logger.debug({ cwd }, "Merge aborted");
+}
+/**
+* Get a list of files with conflicts during a merge.
+*
+* Must be called while a merge is in progress (after simulateMerge() and
+* before abortMerge()).
+*
+* @param cwd - Working directory of the repository
+* @returns   - Array of conflicting file paths
+*/
+async function getConflictingFiles(cwd) {
+	logger.debug({ cwd }, "getConflictingFiles");
+	const result = await spawnGit([
+		"diff",
+		"--name-only",
+		"--diff-filter=U"
+	], { cwd });
+	if (result.code !== 0) {
+		logger.warn({
+			cwd,
+			stderr: result.stderr
+		}, "getConflictingFiles: git diff returned non-zero");
+		return [];
+	}
+	if (result.stdout.trim() === "") return [];
+	return result.stdout.trim().split("\n").filter((f) => f.trim().length > 0);
+}
+/**
+* Perform an actual merge using git merge --no-ff.
+*
+* Should only be called after detectConflicts() confirms there are no conflicts.
+* Creates a merge commit even if fast-forward is possible (--no-ff ensures history).
+*
+* @param branchName  - The source branch to merge
+* @param cwd         - Working directory (must be on the target branch)
+* @returns           - true if merge succeeded, false otherwise
+*/
+async function performMerge(branchName, cwd) {
+	logger.debug({
+		branchName,
+		cwd
+	}, "performMerge");
+	const result = await spawnGit([
+		"merge",
+		"--no-ff",
+		branchName
+	], { cwd });
+	if (result.code !== 0) {
+		logger.warn({
+			branchName,
+			cwd,
+			stderr: result.stderr
+		}, "performMerge: git merge --no-ff failed");
+		return false;
+	}
+	logger.debug({
+		branchName,
+		cwd
+	}, "Merge completed");
+	return true;
+}
+/**
+* Get a list of files changed in the most recent merge.
+*
+* Uses git diff --name-only HEAD~1..HEAD to find files in the merge commit.
+* Falls back to empty array if commit history is insufficient.
+*
+* @param cwd - Working directory of the repository
+* @returns   - Array of file paths that were merged
+*/
+async function getMergedFiles(cwd) {
+	logger.debug({ cwd }, "getMergedFiles");
+	const result = await spawnGit([
+		"diff",
+		"--name-only",
+		"HEAD~1..HEAD"
+	], { cwd });
+	if (result.code !== 0) {
+		const altResult = await spawnGit([
+			"show",
+			"--name-only",
+			"--format=",
+			"HEAD"
+		], { cwd });
+		if (altResult.code !== 0) {
+			logger.warn({
+				cwd,
+				stderr: altResult.stderr
+			}, "getMergedFiles: failed to get merged file list");
+			return [];
+		}
+		return altResult.stdout.trim().split("\n").filter((f) => f.trim().length > 0);
+	}
+	if (result.stdout.trim() === "") return [];
+	return result.stdout.trim().split("\n").filter((f) => f.trim().length > 0);
+}
+
+//#endregion
+export { abortMerge, createWorktree, getConflictingFiles, getMergedFiles, getOrphanedWorktrees, performMerge, removeBranch, removeWorktree, simulateMerge, spawnGit, verifyGitVersion };
+//# sourceMappingURL=git-utils-BtI5eNoN.js.map

package/dist/index.d.ts

@@ -77,7 +77,7 @@ interface CostRecord {
  * Pipeline event type definitions for the NDJSON event protocol.
  *
  * These types form a discriminated union `PipelineEvent` that is emitted
- * on stdout when `substrate auto run --events` is active.
+ * on stdout when `substrate run --events` is active.
  *
  * All events carry a `ts` ISO-8601 timestamp generated at emit time.
  */
@@ -293,6 +293,90 @@ interface SupervisorSummaryEvent {
   /** Number of restart cycles performed by the supervisor */
   restarts: number;
 }
+/**
+ * Emitted when the supervisor's post-run analysis finishes successfully.
+ */
+interface SupervisorAnalysisCompleteEvent {
+  type: 'supervisor:analysis:complete';
+  /** ISO-8601 timestamp generated at emit time */
+  ts: string;
+  /** Pipeline run ID that was analyzed */
+  run_id: string | null;
+}
+/**
+ * Emitted when the supervisor's post-run analysis fails.
+ */
+interface SupervisorAnalysisErrorEvent {
+  type: 'supervisor:analysis:error';
+  /** ISO-8601 timestamp generated at emit time */
+  ts: string;
+  /** Pipeline run ID for which analysis was attempted */
+  run_id: string | null;
+  /** Error message describing why analysis failed */
+  error: string;
+}
+/**
+ * Emitted when the supervisor begins an experiment cycle.
+ */
+interface SupervisorExperimentStartEvent {
+  type: 'supervisor:experiment:start';
+  /** ISO-8601 timestamp generated at emit time */
+  ts: string;
+  /** Pipeline run ID being experimented on */
+  run_id: string | null;
+}
+/**
+ * Emitted when the supervisor skips an experiment cycle (no recommendations or no analysis report).
+ */
+interface SupervisorExperimentSkipEvent {
+  type: 'supervisor:experiment:skip';
+  /** ISO-8601 timestamp generated at emit time */
+  ts: string;
+  /** Pipeline run ID */
+  run_id: string | null;
+  /** Why the experiment was skipped */
+  reason: string;
+}
+/**
+ * Emitted when the supervisor discovers recommendations to experiment with.
+ */
+interface SupervisorExperimentRecommendationsEvent {
+  type: 'supervisor:experiment:recommendations';
+  /** ISO-8601 timestamp generated at emit time */
+  ts: string;
+  /** Pipeline run ID */
+  run_id: string | null;
+  /** Number of recommendations found */
+  count: number;
+}
+/**
+ * Emitted when the supervisor's experiment cycle completes.
+ */
+interface SupervisorExperimentCompleteEvent {
+  type: 'supervisor:experiment:complete';
+  /** ISO-8601 timestamp generated at emit time */
+  ts: string;
+  /** Pipeline run ID */
+  run_id: string | null;
+  /** Number of experiments that resulted in improvement */
+  improved: number;
+  /** Number of experiments with mixed results */
+  mixed: number;
+  /** Number of experiments that caused regression */
+  regressed: number;
+}
+/**
+ * Emitted when the supervisor's experiment cycle fails.
+ */
+interface SupervisorExperimentErrorEvent {
+  type: 'supervisor:experiment:error';
+  /** ISO-8601 timestamp generated at emit time */
+  ts: string;
+  /** Pipeline run ID */
+  run_id: string | null;
+  /** Error message describing why the experiment failed */
+  error: string;
+}
 /**
  * Discriminated union of all pipeline event types.
  *
@@ -305,7 +389,7 @@ interface SupervisorSummaryEvent {
  * }
  * ```
  */
-type PipelineEvent = PipelineStartEvent | PipelineCompleteEvent | StoryPhaseEvent | StoryDoneEvent | StoryEscalationEvent | StoryWarnEvent | StoryLogEvent | PipelineHeartbeatEvent | StoryStallEvent | SupervisorKillEvent | SupervisorRestartEvent | SupervisorAbortEvent | SupervisorSummaryEvent; //#endregion
+type PipelineEvent = PipelineStartEvent | PipelineCompleteEvent | StoryPhaseEvent | StoryDoneEvent | StoryEscalationEvent | StoryWarnEvent | StoryLogEvent | PipelineHeartbeatEvent | StoryStallEvent | SupervisorKillEvent | SupervisorRestartEvent | SupervisorAbortEvent | SupervisorSummaryEvent | SupervisorAnalysisCompleteEvent | SupervisorAnalysisErrorEvent | SupervisorExperimentStartEvent | SupervisorExperimentSkipEvent | SupervisorExperimentRecommendationsEvent | SupervisorExperimentCompleteEvent | SupervisorExperimentErrorEvent; //#endregion
 //#region src/core/errors.d.ts
 
 /**
@@ -968,141 +1052,9 @@ interface TypedEventBus {
  */
 declare function createEventBus(): TypedEventBus;
 
-//#endregion
-//#region src/core/orchestrator.d.ts
-//# sourceMappingURL=event-bus.d.ts.map
-/**
- * Configuration required to initialize the orchestrator.
- */
-interface OrchestratorConfig {
-  /** Path to the SQLite database file (e.g., ".substrate/substrate.db") */
-  databasePath: string;
-  /** Working directory for the orchestrated project */
-  projectRoot: string;
-  /**
-   * Maximum number of concurrent worker tasks.
-   * @default 4
-   */
-  maxConcurrency?: number;
-  /**
-   * Budget cap in USD (0 = unlimited).
-   * @default 0
-   */
-  budgetCapUsd?: number;
-  /**
-   * Budget cap in tokens (0 = unlimited).
-   * @default 0
-   */
-  budgetCapTokens?: number;
-  /** Optional logger level override */
-  logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
-  /**
-   * Path to the substrate config file for hot-reload watching.
-   * If omitted, defaults to <projectRoot>/substrate.config.yaml
-   */
-  configPath?: string;
-  /**
-   * Enable config hot-reload via file watcher.
-   * When true (default), a file watcher is registered on the config file.
-   * Set to false to disable (e.g. in dry-run or --no-watch-config mode).
-   * @default true
-   */
-  enableConfigHotReload?: boolean;
-  /**
-   * Monitor agent configuration.
-   * If omitted, monitor agent is initialized with defaults.
-   */
-  monitor?: {
-    /**
-     * Path to the monitor SQLite database file.
-     * @default ':memory:' (in-memory, non-persistent) when not specified
-     */
-    databasePath?: string;
-    /**
-     * Number of days to retain task metrics.
-     * @default 90
-     */
-    retentionDays?: number;
-    /**
-     * Custom task type taxonomy for classification overrides.
-     */
-    customTaxonomy?: Record<string, string[]>;
-    /**
-     * Enable advisory routing recommendations based on performance data (AC6, FR68).
-     * When true, MonitorAgent.getRecommendation() returns recommendations for routing decisions.
-     * @default false
-     */
-    use_recommendations?: boolean;
-    /**
-     * Minimum success rate improvement (percentage points) required to generate a recommendation.
-     * @default 5.0
-     */
-    recommendation_threshold_percentage?: number;
-    /**
-     * Minimum number of tasks per (agent, task_type) pair before a recommendation is generated.
-     * @default 10
-     */
-    min_sample_size?: number;
-    /**
-     * Number of days of historical data to analyze for recommendations.
-     * @default 90
-     */
-    recommendation_history_days?: number;
-  };
-}
-/**
- * Central orchestration engine — coordinates all modules via the event bus
- * and dependency injection.
- *
- * Lifecycle:
- *  1. Create via `createOrchestrator(config)`
- *  2. Factory emits `orchestrator:ready` when initialization completes
- *  3. Consumers interact with modules via the event bus or injected interfaces
- *  4. On SIGTERM/SIGINT, graceful shutdown is triggered automatically
- *  5. Call `shutdown()` explicitly for programmatic shutdown
- */
-interface Orchestrator {
-  /**
-   * The typed event bus for this orchestrator instance.
-   * Modules and consumers use this to subscribe to and emit events.
-   */
-  readonly eventBus: TypedEventBus;
-  /**
-   * Whether the orchestrator has been fully initialized.
-   */
-  readonly isReady: boolean;
-  /**
-   * Perform a graceful shutdown of all modules.
-   * Calls shutdown() on all services in reverse initialization order.
-   * Safe to call multiple times — subsequent calls are no-ops.
-   */
-  shutdown(): Promise<void>;
-}
-
-//#endregion
-//#region src/core/orchestrator-impl.d.ts
-//# sourceMappingURL=orchestrator.d.ts.map
-/**
- * Initialize the orchestrator with all modules wired via dependency injection.
- *
- * Steps performed:
- *  1. Create the TypedEventBus
- *  2. Create the SQLite database service
- *  3. Instantiate all modules (TaskGraphEngine, RoutingEngine, WorkerManager,
- *     BudgetTracker, GitManager) with constructor injection
- *  4. Register all modules in the ServiceRegistry
- *  5. Call initialize() on all services in registration order
- *  6. Register SIGTERM/SIGINT graceful shutdown handlers
- *  7. Emit orchestrator:ready
- *
- * @param config - Orchestrator configuration
- * @returns Initialized Orchestrator instance
- */
-declare function createOrchestrator(config: OrchestratorConfig): Promise<Orchestrator>;
-
 //#endregion
 //#region src/core/di.d.ts
-//# sourceMappingURL=orchestrator-impl.d.ts.map
+//# sourceMappingURL=event-bus.d.ts.map
 /**
  * Dependency injection container and service registry.
  *
@@ -1717,7 +1669,7 @@ declare function printNonTtyWarning(): void;
 //#region src/tui/types.d.ts
 //# sourceMappingURL=app.d.ts.map
 /**
- * TUI Dashboard types for substrate auto run --tui
+ * TUI Dashboard types for substrate run --tui
  *
  * These types define the internal state model used by the TUI components.
  */
@@ -1792,5 +1744,5 @@ interface TuiState {
 //#endregion
 //# sourceMappingURL=types.d.ts.map
 
-export { AdapterCapabilities, AdapterDiscoveryResult, AdapterHealthResult, AdapterOptions, AdapterRegistry, AdtError, AgentCapability, AgentId, BaseService, BillingMode, BudgetExceededError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, CostRecord, DiscoveryReport, EscalationIssue, GeminiCLIAdapter, GitError, LogLevel, Orchestrator, OrchestratorConfig, OrchestratorEvents, PipelineCompleteEvent, PipelineEvent, PipelinePhase, PipelineStartEvent, PlanParseResult, PlanRequest, PlannedTask, RecoveryError, ServiceRegistry, SessionConfig, SessionStatus, SpawnCommand, StoryDoneEvent, StoryEscalationEvent, StoryLogEvent, StoryPhaseEvent, StoryPhaseLabel, StoryStatus, StoryWarnEvent, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, TaskId, TaskNode, TaskPriority, TaskResult, TaskStatus, TokenEstimate, TuiApp, TuiLogEntry, TuiState, TuiStoryState, TuiView, TypedEventBus, WorkerAdapter, WorkerError, WorkerId, WorkerNotFoundError, assertDefined, childLogger, createEventBus, createLogger, createOrchestrator, createTuiApp, deepClone, formatDuration, generateId, isPlainObject, isTuiCapable, logger, printNonTtyWarning, sleep, withRetry };
+export { AdapterCapabilities, AdapterDiscoveryResult, AdapterHealthResult, AdapterOptions, AdapterRegistry, AdtError, AgentCapability, AgentId, BaseService, BillingMode, BudgetExceededError, ClaudeCodeAdapter, CodexCLIAdapter, ConfigError, ConfigIncompatibleFormatError, CostRecord, DiscoveryReport, EscalationIssue, GeminiCLIAdapter, GitError, LogLevel, OrchestratorEvents, PipelineCompleteEvent, PipelineEvent, PipelinePhase, PipelineStartEvent, PlanParseResult, PlanRequest, PlannedTask, RecoveryError, ServiceRegistry, SessionConfig, SessionStatus, SpawnCommand, StoryDoneEvent, StoryEscalationEvent, StoryLogEvent, StoryPhaseEvent, StoryPhaseLabel, StoryStatus, StoryWarnEvent, TaskConfigError, TaskGraphCycleError, TaskGraphError, TaskGraphIncompatibleFormatError, TaskId, TaskNode, TaskPriority, TaskResult, TaskStatus, TokenEstimate, TuiApp, TuiLogEntry, TuiState, TuiStoryState, TuiView, TypedEventBus, WorkerAdapter, WorkerError, WorkerId, WorkerNotFoundError, assertDefined, childLogger, createEventBus, createLogger, createTuiApp, deepClone, formatDuration, generateId, isPlainObject, isTuiCapable, logger, printNonTtyWarning, sleep, withRetry };
 //# sourceMappingURL=index.d.ts.map