@bastani/atomic 0.9.12 → 0.9.13-alpha.1

package/dist/builtin/subagents/src/runs/background/subagent-runner-types.ts

@@ -1,210 +0,0 @@
-import type { Message } from "@earendil-works/pi-ai/compat";
-import type { SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
-import type {
-	ActivityState,
-	ArtifactConfig,
-	ArtifactPaths,
-	AsyncParallelGroupStatus,
-	AsyncStatus,
-	ChainOutputMap,
-	MaxOutputConfig,
-	ModelAttempt,
-	NestedRouteInfo,
-	ResolvedControlConfig,
-	SubagentRunMode,
-	TokenUsage,
-	Usage,
-	WorkflowGraphSnapshot,
-} from "../../shared/types.ts";
-import type { RunnerStep, RunnerSubagentStep as SubagentStep } from "../shared/parallel-utils.ts";
-import type { WorktreeSetup } from "../shared/worktree.ts";
-
-export interface SubagentRunConfig {
-	id: string;
-	steps: RunnerStep[];
-	resultPath: string;
-	cwd: string;
-	placeholder: string;
-	taskIndex?: number;
-	totalTasks?: number;
-	maxOutput?: MaxOutputConfig;
-	artifactsDir?: string;
-	artifactConfig?: Partial<ArtifactConfig>;
-	share?: boolean;
-	sessionDir?: string;
-	asyncDir: string;
-	sessionId?: string | null;
-	piPackageRoot?: string;
-	piArgv1?: string;
-	worktreeSetupHook?: string;
-	worktreeSetupHookTimeoutMs?: number;
-	controlConfig?: ResolvedControlConfig;
-	controlIntercomTarget?: string;
-	childIntercomTargets?: Array<string | undefined>;
-	supervisorAuthorizations?: Array<SupervisorAuthorization | undefined>;
-	dynamicSupervisorAuthorizations?: Record<number, SupervisorAuthorization[]>;
-	resultMode?: SubagentRunMode;
-	dynamicFanoutMaxItems?: number;
-	workflowGraph?: WorkflowGraphSnapshot;
-	nestedRoute?: NestedRouteInfo;
-	workflowStageSubagentGuard?: boolean;
-	nestedSelf?: {
-		parentRunId: string;
-		parentStepIndex?: number;
-		depth: number;
-		path?: Array<{ runId: string; stepIndex?: number; agent?: string }>;
-	};
-}
-
-export interface StepResult {
-	agent: string;
-	output: string;
-	error?: string;
-	success: boolean;
-	exitCode?: number | null;
-	skipped?: boolean;
-	sessionFile?: string;
-	intercomTarget?: string;
-	model?: string;
-	fastMode?: boolean;
-	attemptedModels?: string[];
-	modelAttempts?: ModelAttempt[];
-	artifactPaths?: ArtifactPaths;
-	truncated?: boolean;
-	structuredOutput?: unknown;
-	structuredOutputPath?: string;
-	structuredOutputSchemaPath?: string;
-}
-
-export interface ChildEventContext {
-	eventsPath: string;
-	runId: string;
-	stepIndex: number;
-	agent: string;
-}
-
-export interface ChildUsage {
-	input?: number;
-	inputTokens?: number;
-	output?: number;
-	outputTokens?: number;
-	cacheRead?: number;
-	cacheWrite?: number;
-	cost?: { total?: number };
-}
-
-export type ChildMessage = Message & {
-	model?: string;
-	errorMessage?: string;
-	usage?: ChildUsage;
-};
-
-export interface ChildEvent {
-	type?: string;
-	message?: ChildMessage;
-	toolName?: string;
-	args?: Record<string, unknown>;
-}
-
-export interface RunPiStreamingResult {
-	stderr: string;
-	exitCode: number | null;
-	messages: Message[];
-	usage: Usage;
-	model?: string;
-	error?: string;
-	finalOutput: string;
-	interrupted?: boolean;
-	modelFailureSignal?: unknown;
-}
-
-export interface SingleStepContext {
-	previousOutput: string;
-	outputs?: ChainOutputMap;
-	placeholder: string;
-	cwd: string;
-	sessionEnabled: boolean;
-	sessionDir?: string;
-	artifactsDir?: string;
-	artifactConfig?: Partial<ArtifactConfig>;
-	id: string;
-	flatIndex: number;
-	flatStepCount: number;
-	outputFile: string;
-	piPackageRoot?: string;
-	piArgv1?: string;
-	registerInterrupt?: (interrupt: (() => void) | undefined) => void;
-	childIntercomTarget?: string;
-	orchestratorIntercomTarget?: string;
-	supervisorAuthorization?: SupervisorAuthorization;
-	nestedRoute?: NestedRouteInfo;
-	onAttemptStart?: (attempt: { model?: string; thinking?: string; fastMode?: boolean }) => void;
-	onChildEvent?: (event: ChildEvent) => void;
-	workflowStageSubagentGuard?: boolean;
-}
-
-export type RunnerStatusStep = NonNullable<AsyncStatus["steps"]>[number] & {
-	exitCode?: number | null;
-};
-
-export type RunnerStatusPayload = Omit<
-	AsyncStatus,
-	"steps" | "parallelGroups" | "pid" | "cwd" | "currentStep" | "chainStepCount" | "lastUpdate"
-> & {
-	pid: number;
-	cwd: string;
-	currentStep: number;
-	chainStepCount: number;
-	parallelGroups: AsyncParallelGroupStatus[];
-	steps: RunnerStatusStep[];
-	lastUpdate: number;
-	artifactsDir?: string;
-	shareUrl?: string;
-	gistUrl?: string;
-	shareError?: string;
-	error?: string;
-};
-
-export interface RunnerExecutionState {
-	config: SubagentRunConfig;
-	id: string;
-	steps: RunnerStep[];
-	resultPath: string;
-	cwd: string;
-	placeholder: string;
-	taskIndex?: number;
-	totalTasks?: number;
-	maxOutput?: MaxOutputConfig;
-	artifactsDir?: string;
-	artifactConfig?: Partial<ArtifactConfig>;
-	previousOutput: string;
-	outputs: ChainOutputMap;
-	results: StepResult[];
-	overallStartTime: number;
-	shareEnabled: boolean;
-	asyncDir: string;
-	statusPath: string;
-	eventsPath: string;
-	logPath: string;
-	controlConfig: ResolvedControlConfig;
-	activeChildInterrupt?: (() => void) | undefined;
-	interrupted: boolean;
-	currentActivityState?: ActivityState;
-	activityTimer?: NodeJS.Timeout;
-	previousCumulativeTokens: TokenUsage;
-	latestSessionFile?: string;
-	flatSteps: SubagentStep[];
-	sessionEnabled: boolean;
-	statusPayload: RunnerStatusPayload;
-	flatIndex: number;
-	mutatingFailureStates: Array<
-		ReturnType<typeof import("../shared/long-running-guard.ts").createMutatingFailureState>
-	>;
-	pendingToolResults: Array<{ tool: string; path?: string; mutates: boolean; startedAt?: number } | undefined>;
-	emittedControlEventKeys: Set<string>;
-	activeLongRunningSteps: Set<number>;
-}
-
-export type ParallelGroup = Extract<RunnerStep, { parallel: SubagentStep[] }>;
-export type DynamicGroup = Extract<RunnerStep, { collect: { as: string } }>;
-export type { RunnerStep, SubagentStep, WorktreeSetup };

package/dist/builtin/subagents/src/runs/background/subagent-runner-utils.ts

@@ -1,69 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ModelAttempt, TokenUsage, Usage } from "../../shared/types.ts";
-import type { RunnerStatusStep, SubagentStep } from "./subagent-runner-types.ts";
-
-export function findLatestSessionFile(sessionDir: string): string | null {
-	try {
-		const files = fs
-			.readdirSync(sessionDir)
-			.filter((f) => f.endsWith(".jsonl"))
-			.map((f) => path.join(sessionDir, f));
-		if (files.length === 0) return null;
-		files.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-		return files[0] ?? null;
-	} catch {
-		return null;
-	}
-}
-
-export function emptyUsage(): Usage {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-}
-
-export function tokenUsageFromAttempts(attempts: ModelAttempt[] | undefined): TokenUsage | null {
-	if (!attempts || attempts.length === 0) return null;
-	let input = 0;
-	let output = 0;
-	for (const attempt of attempts) {
-		input += attempt.usage?.input ?? 0;
-		output += attempt.usage?.output ?? 0;
-	}
-	const total = input + output;
-	return total > 0 ? { input, output, total } : null;
-}
-
-export function appendRecentStepOutput(step: RunnerStatusStep, lines: string[]): void {
-	const nonEmpty = lines.filter((line) => line.trim());
-	if (nonEmpty.length === 0) return;
-	step.recentOutput ??= [];
-	step.recentOutput.push(...nonEmpty);
-	if (step.recentOutput.length > 50) {
-		step.recentOutput.splice(0, step.recentOutput.length - 50);
-	}
-}
-
-export function resetStepLiveDetail(step: RunnerStatusStep): void {
-	step.currentTool = undefined;
-	step.currentToolArgs = undefined;
-	step.currentToolStartedAt = undefined;
-	step.currentPath = undefined;
-	step.recentTools = [];
-	step.recentOutput = [];
-}
-
-export function fastModeForStepAttempt(step: SubagentStep, model: string | undefined): boolean | undefined {
-	if (model && step.modelFastModes && Object.hasOwn(step.modelFastModes, model)) {
-		return step.modelFastModes[model];
-	}
-	if (model === undefined || model === step.model) return step.fastMode;
-	return undefined;
-}
-
-export function formatDuration(ms: number): string {
-	if (ms < 1000) return `${ms}ms`;
-	if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-	const minutes = Math.floor(ms / 60000);
-	const seconds = Math.floor((ms % 60000) / 1000);
-	return `${minutes}m${seconds}s`;
-}

package/dist/builtin/subagents/src/runs/background/subagent-runner.ts

@@ -1,90 +0,0 @@
-import * as fs from "node:fs";
-import { appendJsonl } from "../../shared/artifacts.ts";
-import { isDynamicRunnerGroup, isParallelGroup } from "../shared/parallel-utils.ts";
-import { runDynamicGroup } from "./subagent-runner-dynamic.ts";
-import { finalizeRun } from "./subagent-runner-finalize.ts";
-import { runParallelGroup } from "./subagent-runner-parallel.ts";
-import { runSequentialStep } from "./subagent-runner-sequential.ts";
-import { createRunnerExecutionState, interruptRunner, startActivityTimer } from "./subagent-runner-state.ts";
-import type { SubagentRunConfig, SubagentStep } from "./subagent-runner-types.ts";
-
-const ASYNC_INTERRUPT_SIGNAL: NodeJS.Signals = process.platform === "win32" ? "SIGBREAK" : "SIGUSR2";
-
-async function runSubagent(config: SubagentRunConfig): Promise<void> {
-	const state = createRunnerExecutionState(config);
-	startActivityTimer(state);
-	const onInterrupt = () => interruptRunner(state);
-	process.on(ASYNC_INTERRUPT_SIGNAL, onInterrupt);
-	appendJsonl(
-		state.eventsPath,
-		JSON.stringify({
-			type: "subagent.run.started",
-			ts: state.overallStartTime,
-			runId: state.id,
-			mode: state.statusPayload.mode,
-			cwd: state.cwd,
-			pid: process.pid,
-		}),
-	);
-
-	try {
-		for (let stepIndex = 0; stepIndex < state.steps.length; stepIndex++) {
-			if (state.interrupted) break;
-			const step = state.steps[stepIndex];
-			let shouldContinue = true;
-			if (isDynamicRunnerGroup(step)) {
-				shouldContinue = await runDynamicGroup(state, step, stepIndex);
-			} else if (isParallelGroup(step)) {
-				shouldContinue = await runParallelGroup(state, step, stepIndex);
-			} else {
-				shouldContinue = await runSequentialStep(state, step as SubagentStep, stepIndex);
-			}
-			if (!shouldContinue) break;
-		}
-		await finalizeRun(state);
-	} finally {
-		process.off(ASYNC_INTERRUPT_SIGNAL, onInterrupt);
-	}
-}
-
-function parseConfig(input: string): SubagentRunConfig {
-	return JSON.parse(input) as SubagentRunConfig;
-}
-
-function runConfig(config: SubagentRunConfig): void {
-	runSubagent(config).catch((runErr) => {
-		console.error("Subagent runner error:", runErr);
-		process.exit(1);
-	});
-}
-
-const configArg = process.argv[2];
-if (configArg) {
-	try {
-		const configJson = fs.readFileSync(configArg, "utf-8");
-		const config = parseConfig(configJson);
-		try {
-			fs.unlinkSync(configArg);
-		} catch {
-			// Temp config cleanup is best effort.
-		}
-		runConfig(config);
-	} catch (err) {
-		console.error("Subagent runner error:", err);
-		process.exit(1);
-	}
-} else {
-	let input = "";
-	process.stdin.setEncoding("utf-8");
-	process.stdin.on("data", (chunk) => {
-		input += chunk;
-	});
-	process.stdin.on("end", () => {
-		try {
-			runConfig(parseConfig(input));
-		} catch (err) {
-			console.error("Subagent runner error:", err);
-			process.exit(1);
-		}
-	});
-}

package/dist/builtin/subagents/src/runs/background/top-level-async.ts

@@ -1,12 +0,0 @@
-interface AsyncOverrideParams {
-	async?: boolean;
-}
-
-export function applyForceTopLevelAsyncOverride<T extends AsyncOverrideParams>(
-	params: T,
-	depth: number,
-	forceTopLevelAsync: boolean,
-): T {
-	if (!(depth === 0 && forceTopLevelAsync)) return params;
-	return { ...params, async: true };
-}

package/dist/builtin/subagents/src/runs/foreground/execution-attempt-control.ts

@@ -1,140 +0,0 @@
-import type { AgentConfig } from "../../agents/agents.ts";
-import type { AgentProgress, ControlEvent, RunSyncOptions, SingleResult } from "../../shared/types.ts";
-import { nextLongRunningTrigger } from "../shared/long-running-guard.ts";
-import {
-	buildControlEvent,
-	claimControlNotification,
-	DEFAULT_CONTROL_CONFIG,
-	deriveActivityState,
-	shouldNotifyControlEvent,
-} from "../shared/subagent-control.ts";
-
-export type NeedsAttentionInput = {
-	message?: string;
-	reason?: ControlEvent["reason"];
-	recentFailureSummary?: string;
-	currentTool?: string;
-	currentPath?: string;
-	currentToolDurationMs?: number;
-};
-
-export type AttemptControlRuntime = {
-	config: NonNullable<RunSyncOptions["controlConfig"]>;
-	allControlEvents: ControlEvent[];
-	drainPendingControlEvents(): ControlEvent[] | undefined;
-	emitNeedsAttention(now: number, input?: NeedsAttentionInput): boolean;
-	updateActivityState(now: number): boolean;
-};
-
-export function createAttemptControlRuntime(input: {
-	options: RunSyncOptions;
-	agent: AgentConfig;
-	result: SingleResult;
-	progress: AgentProgress;
-	startTime: number;
-}): AttemptControlRuntime {
-	const controlConfig = input.options.controlConfig ?? DEFAULT_CONTROL_CONFIG;
-	const allControlEvents: ControlEvent[] = [];
-	let pendingControlEvents: ControlEvent[] = [];
-	const emittedControlEventKeys = new Set<string>();
-	let activeLongRunningNotified = false;
-
-	const currentToolDurationMs = (now: number) =>
-		input.progress.currentToolStartedAt ? Math.max(0, now - input.progress.currentToolStartedAt) : undefined;
-
-	const emitControlEvent = (event: ControlEvent) => {
-		if (!shouldNotifyControlEvent(controlConfig, event)) return;
-		if (!claimControlNotification(controlConfig, event, emittedControlEventKeys)) return;
-		allControlEvents.push(event);
-		pendingControlEvents.push(event);
-		input.options.onControlEvent?.(event);
-	};
-
-	const emitNeedsAttention = (now: number, details: NeedsAttentionInput = {}): boolean => {
-		if (!controlConfig.enabled) return false;
-		const previous = input.progress.activityState;
-		input.progress.activityState = "needs_attention";
-		emitControlEvent(
-			buildControlEvent({
-				type: "needs_attention",
-				from: previous,
-				to: "needs_attention",
-				runId: input.options.runId,
-				agent: input.agent.name,
-				index: input.options.index,
-				ts: now,
-				lastActivityAt: input.progress.lastActivityAt,
-				message: details.message,
-				reason: details.reason ?? "idle",
-				turns: input.result.usage.turns,
-				tokens: input.progress.tokens,
-				toolCount: input.progress.toolCount,
-				currentTool: details.currentTool ?? input.progress.currentTool,
-				currentToolDurationMs: details.currentToolDurationMs ?? currentToolDurationMs(now),
-				currentPath: details.currentPath ?? input.progress.currentPath,
-				recentFailureSummary: details.recentFailureSummary,
-			}),
-		);
-		return previous !== "needs_attention";
-	};
-
-	const emitActiveLongRunning = (now: number, reason: ControlEvent["reason"]): boolean => {
-		if (!controlConfig.enabled || activeLongRunningNotified || input.progress.activityState === "needs_attention")
-			return false;
-		activeLongRunningNotified = true;
-		const previous = input.progress.activityState;
-		input.progress.activityState = "active_long_running";
-		emitControlEvent(
-			buildControlEvent({
-				type: "active_long_running",
-				from: previous,
-				to: "active_long_running",
-				runId: input.options.runId,
-				agent: input.agent.name,
-				index: input.options.index,
-				ts: now,
-				message: `${input.agent.name} is still active but long-running`,
-				reason,
-				turns: input.result.usage.turns,
-				tokens: input.progress.tokens,
-				toolCount: input.progress.toolCount,
-				currentTool: input.progress.currentTool,
-				currentToolDurationMs: currentToolDurationMs(now),
-				currentPath: input.progress.currentPath,
-				elapsedMs: now - input.startTime,
-			}),
-		);
-		return true;
-	};
-
-	return {
-		config: controlConfig,
-		allControlEvents,
-		drainPendingControlEvents: () => {
-			if (pendingControlEvents.length === 0) return undefined;
-			const events = pendingControlEvents;
-			pendingControlEvents = [];
-			return events;
-		},
-		emitNeedsAttention,
-		updateActivityState: (now: number) => {
-			if (!controlConfig.enabled) return false;
-			const idleState = deriveActivityState({
-				config: controlConfig,
-				startedAt: input.startTime,
-				lastActivityAt: input.progress.lastActivityAt,
-				now,
-			});
-			if (idleState === "needs_attention") {
-				return input.progress.activityState === "needs_attention" ? false : emitNeedsAttention(now);
-			}
-			const activeReason = nextLongRunningTrigger(controlConfig, {
-				startedAt: input.startTime,
-				now,
-				turns: input.result.usage.turns,
-				tokens: input.progress.tokens,
-			});
-			return activeReason ? emitActiveLongRunning(now, activeReason) : false;
-		},
-	};
-}

package/dist/builtin/subagents/src/runs/foreground/execution-attempt-finalize.ts

@@ -1,108 +0,0 @@
-import type { AgentProgress, ControlEvent, RunSyncOptions, SingleResult } from "../../shared/types.ts";
-import { detectSubagentError, getFinalOutput } from "../../shared/utils.ts";
-import { formatSavedOutputReference, resolveSingleOutput } from "../shared/single-output.ts";
-import { readStructuredOutput } from "../shared/structured-output.ts";
-import type { RunSingleAttemptShared } from "./execution-attempt-types.ts";
-import { artifactOutputByResult, snapshotProgress, snapshotResult } from "./execution-utils.ts";
-
-export function finalizeSingleAttempt(input: {
-	result: SingleResult;
-	progress: AgentProgress;
-	exitCode: number;
-	interruptedByControl: boolean;
-	allControlEvents: ControlEvent[];
-	options: RunSyncOptions;
-	shared: RunSingleAttemptShared;
-	startTime: number;
-}): SingleResult {
-	const { result, progress, options, shared, allControlEvents } = input;
-	result.exitCode = input.exitCode;
-	if (input.interruptedByControl) {
-		result.exitCode = 0;
-		result.interrupted = true;
-		result.error = undefined;
-		result.finalOutput = result.finalOutput || "Interrupted. Waiting for explicit next action.";
-		result.controlEvents = allControlEvents.length ? allControlEvents : undefined;
-		progress.activityState = undefined;
-		progress.durationMs = Date.now() - input.startTime;
-		result.progressSummary = {
-			toolCount: progress.toolCount,
-			tokens: progress.tokens,
-			durationMs: progress.durationMs,
-		};
-		return result;
-	}
-	if (result.detached) {
-		result.exitCode = -2;
-		result.finalOutput = "Detached for intercom coordination; awaiting the child's eventual result.";
-		return result;
-	}
-
-	if (result.error && result.exitCode === 0) result.exitCode = 1;
-	if (result.exitCode === 0 && !result.error) {
-		const errInfo = detectSubagentError(result.messages ?? []);
-		if (errInfo.hasError) {
-			result.exitCode = errInfo.exitCode ?? 1;
-			result.error = errInfo.details
-				? `${errInfo.errorType} failed (exit ${errInfo.exitCode}): ${errInfo.details}`
-				: `${errInfo.errorType} failed with exit code ${errInfo.exitCode}`;
-		}
-	}
-	if (options.structuredOutput && result.exitCode === 0 && !result.error) {
-		const structured = readStructuredOutput(options.structuredOutput);
-		result.structuredOutputSchemaPath = options.structuredOutput.schemaPath;
-		result.structuredOutputPath = options.structuredOutput.outputPath;
-		if (structured.error) {
-			result.exitCode = 1;
-			result.error = structured.error;
-		} else {
-			result.structuredOutput = structured.value;
-		}
-	}
-
-	progress.status = result.exitCode === 0 ? "completed" : "failed";
-	progress.durationMs = Date.now() - input.startTime;
-	if (result.error) {
-		progress.error = result.error;
-		if (progress.currentTool) progress.failedTool = progress.currentTool;
-	}
-
-	result.progressSummary = {
-		toolCount: progress.toolCount,
-		tokens: progress.tokens,
-		durationMs: progress.durationMs,
-	};
-
-	let fullOutput = getFinalOutput(result.messages ?? []);
-	if (options.outputPath && result.exitCode === 0) {
-		const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot);
-		fullOutput = resolvedOutput.fullOutput;
-		result.savedOutputPath = resolvedOutput.savedPath;
-		result.outputSaveError = resolvedOutput.saveError;
-		if (resolvedOutput.savedPath) {
-			result.outputReference = formatSavedOutputReference(resolvedOutput.savedPath, fullOutput);
-		}
-	}
-	artifactOutputByResult.set(result, fullOutput);
-	result.outputMode = options.outputMode ?? "inline";
-	result.finalOutput =
-		options.outputMode === "file-only" && result.savedOutputPath && result.outputReference
-			? result.outputReference.message
-			: fullOutput;
-	result.controlEvents = allControlEvents.length ? allControlEvents : undefined;
-	if (options.onUpdate) {
-		const finalText = result.finalOutput || result.error || "(no output)";
-		const progressSnapshot = snapshotProgress(progress);
-		const resultSnapshot = snapshotResult(result, progressSnapshot);
-		options.onUpdate({
-			content: [{ type: "text", text: finalText }],
-			details: {
-				mode: "single",
-				results: [resultSnapshot],
-				progress: [progressSnapshot],
-				controlEvents: allControlEvents.length ? allControlEvents : undefined,
-			},
-		});
-	}
-	return result;
-}

package/dist/builtin/subagents/src/runs/foreground/execution-attempt-types.ts

@@ -1,17 +0,0 @@
-import type { CodexFastModeResolvedSettings, CodexFastModeScope } from "@bastani/atomic";
-import type { ArtifactPaths } from "../../shared/types.ts";
-import type { SingleOutputSnapshot } from "../shared/single-output.ts";
-
-export type RunSingleAttemptShared = {
-	sessionEnabled: boolean;
-	systemPrompt: string;
-	resolvedSkillNames?: string[];
-	skillsWarning?: string;
-	jsonlPath?: string;
-	artifactPaths?: ArtifactPaths;
-	attemptNotes: string[];
-	outputSnapshot?: SingleOutputSnapshot;
-	fastModeSettings: CodexFastModeResolvedSettings;
-	fastModeScope: CodexFastModeScope;
-	originalTask?: string;
-};