@clinebot/core 0.0.35 → 0.0.37

package/src/extensions/tools/runtime.ts

@@ -0,0 +1,261 @@
+import type { CoreAgentMode } from "../../types/config";
+import {
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
+} from "./model-tool-routing";
+import { resolveToolPresetName, ToolPresets } from "./presets";
+import { createSpawnAgentTool } from "./team/spawn-agent-tool";
+import { TEAM_TOOL_NAMES } from "./team/team-tools";
+import type { DefaultToolsConfig } from "./types";
+
+export interface ToolCatalogEntry {
+	id: string;
+	description: string;
+	defaultEnabled: boolean;
+	headlessToolNames: string[];
+}
+
+export interface BuiltinToolAvailabilityContext {
+	mode?: CoreAgentMode;
+	providerId?: string;
+	modelId?: string;
+	enableSpawnAgent?: boolean;
+	enableAgentTeams?: boolean;
+	disabledToolIds?: ReadonlySet<string>;
+}
+
+type RuntimeToolCatalogEntry = Omit<ToolCatalogEntry, "defaultEnabled">;
+
+const BASE_TOOL_CATALOG: readonly RuntimeToolCatalogEntry[] = [
+	{
+		id: "read_files",
+		description:
+			"Read the full content of text or image files at the provided absolute paths, or return only an inclusive one-based line range when start_line/end_line are provided.",
+		headlessToolNames: ["read_files"],
+	},
+	{
+		id: "search_codebase",
+		description:
+			"Perform regex pattern searches across the codebase for code patterns, definitions, imports, and other text matches.",
+		headlessToolNames: ["search_codebase"],
+	},
+	{
+		id: "run_commands",
+		description:
+			"Run shell commands from the root of the workspace for listing files, checking git status, builds, tests, and similar tasks.",
+		headlessToolNames: ["run_commands"],
+	},
+	{
+		id: "editor",
+		description:
+			"Make controlled filesystem edits on text files with create, replace, and insert operations.",
+		headlessToolNames: ["editor"],
+	},
+	{
+		id: "fetch_web_content",
+		description:
+			"Fetch URL content and analyze it with a prompt describing what to extract.",
+		headlessToolNames: ["fetch_web_content"],
+	},
+	{
+		id: "skills",
+		description:
+			"Execute a configured skill within the main conversation when a matching skill exists for the task.",
+		headlessToolNames: ["skills"],
+	},
+	{
+		id: "ask_question",
+		description:
+			"Ask the user a single clarifying question with 2-5 selectable options.",
+		headlessToolNames: ["ask_question"],
+	},
+	{
+		id: "spawn_agent",
+		description: createSpawnAgentTool({ configProvider: {} as never })
+			.description,
+		headlessToolNames: ["spawn_agent"],
+	},
+	{
+		id: "teams",
+		description:
+			"Enable team collaboration tools for teammate management, task coordination, mailbox messaging, mission logs, and outcomes.",
+		headlessToolNames: [...TEAM_TOOL_NAMES],
+	},
+] as const;
+
+const TOOL_NAME_TO_FLAG: Partial<
+	Record<
+		string,
+		keyof Pick<
+			DefaultToolsConfig,
+			| "enableReadFiles"
+			| "enableSearch"
+			| "enableBash"
+			| "enableWebFetch"
+			| "enableApplyPatch"
+			| "enableEditor"
+			| "enableSkills"
+			| "enableAskQuestion"
+			| "enableSubmitAndExit"
+		>
+	>
+> = {
+	read_files: "enableReadFiles",
+	search_codebase: "enableSearch",
+	run_commands: "enableBash",
+	fetch_web_content: "enableWebFetch",
+	apply_patch: "enableApplyPatch",
+	editor: "enableEditor",
+	skills: "enableSkills",
+	ask_question: "enableAskQuestion",
+};
+
+function resolveContextMode(
+	mode?: BuiltinToolAvailabilityContext["mode"],
+): CoreAgentMode {
+	return mode === "plan" || mode === "yolo" ? mode : "act";
+}
+
+type ResolvedToolFlags = Pick<
+	DefaultToolsConfig,
+	| "enableReadFiles"
+	| "enableSearch"
+	| "enableBash"
+	| "enableWebFetch"
+	| "enableApplyPatch"
+	| "enableEditor"
+	| "enableSkills"
+	| "enableAskQuestion"
+	| "enableSubmitAndExit"
+> & {
+	enableSpawnAgent?: boolean;
+	enableAgentTeams?: boolean;
+};
+
+function resolvePresetFlags(context: BuiltinToolAvailabilityContext): {
+	mode: CoreAgentMode;
+	flags: ResolvedToolFlags;
+} {
+	const mode = resolveContextMode(context.mode);
+	const preset = ToolPresets[resolveToolPresetName({ mode })];
+	const routed = resolveToolRoutingConfig(
+		context.providerId ?? "",
+		context.modelId ?? "",
+		mode,
+		DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	);
+	return {
+		mode,
+		flags: {
+			...preset,
+			...routed,
+			...(typeof context.enableSpawnAgent === "boolean"
+				? { enableSpawnAgent: context.enableSpawnAgent }
+				: {}),
+			...(typeof context.enableAgentTeams === "boolean"
+				? { enableAgentTeams: context.enableAgentTeams }
+				: {}),
+		},
+	};
+}
+
+function isEntryEnabledByDefault(
+	entryId: string,
+	context: BuiltinToolAvailabilityContext,
+): boolean {
+	if (context.disabledToolIds?.has(entryId)) {
+		return false;
+	}
+
+	const { flags } = resolvePresetFlags(context);
+	if (entryId === "spawn_agent") {
+		return flags.enableSpawnAgent === true;
+	}
+	if (entryId === "teams") {
+		return flags.enableAgentTeams === true;
+	}
+	if (entryId === "editor") {
+		return flags.enableEditor === true || flags.enableApplyPatch === true;
+	}
+
+	const flag = TOOL_NAME_TO_FLAG[entryId];
+	return flag ? flags[flag] === true : false;
+}
+
+function buildCatalogEntry(
+	entry: RuntimeToolCatalogEntry,
+	context: BuiltinToolAvailabilityContext,
+): ToolCatalogEntry {
+	if (entry.id === "editor") {
+		const { flags } = resolvePresetFlags(context);
+		const usesApplyPatch =
+			flags.enableApplyPatch === true && flags.enableEditor !== true;
+		return {
+			...entry,
+			defaultEnabled: isEntryEnabledByDefault(entry.id, context),
+			headlessToolNames: [usesApplyPatch ? "apply_patch" : "editor"],
+		};
+	}
+
+	return {
+		...entry,
+		defaultEnabled: isEntryEnabledByDefault(entry.id, context),
+	};
+}
+
+export function getCoreBuiltinToolCatalog(
+	context: BuiltinToolAvailabilityContext = {},
+): ToolCatalogEntry[] {
+	return BASE_TOOL_CATALOG.map((entry) => buildCatalogEntry(entry, context));
+}
+
+export function getCoreDefaultEnabledToolIds(
+	context: BuiltinToolAvailabilityContext = {},
+): string[] {
+	return getCoreBuiltinToolCatalog(context)
+		.filter((entry) => entry.defaultEnabled)
+		.map((entry) => entry.id);
+}
+
+export function resolveCoreSelectedToolIds(input: {
+	enabled: boolean;
+	allowlist?: string[];
+	availabilityContext?: BuiltinToolAvailabilityContext;
+}): Set<string> {
+	if (!input.enabled) {
+		return new Set();
+	}
+
+	const catalog = getCoreBuiltinToolCatalog(input.availabilityContext);
+	const known = new Set(catalog.map((entry) => entry.id));
+	if (!input.allowlist || input.allowlist.length === 0) {
+		return new Set(
+			catalog.filter((entry) => entry.defaultEnabled).map((entry) => entry.id),
+		);
+	}
+
+	for (const id of input.allowlist) {
+		if (!known.has(id)) {
+			throw new Error(
+				`Unknown tool "${id}". Available tools: ${catalog.map((entry) => entry.id).join(", ")}`,
+			);
+		}
+	}
+	return new Set(input.allowlist);
+}
+
+export function getCoreHeadlessToolNames(
+	selectedToolIds: ReadonlySet<string>,
+	context: BuiltinToolAvailabilityContext = {},
+): string[] {
+	return getCoreBuiltinToolCatalog(context)
+		.filter((entry) => selectedToolIds.has(entry.id))
+		.flatMap((entry) => entry.headlessToolNames);
+}
+
+export function getCoreAcpToolNames(
+	selectedToolIds: ReadonlySet<string>,
+	context: BuiltinToolAvailabilityContext = {},
+): string[] {
+	return getCoreHeadlessToolNames(selectedToolIds, context);
+}

package/src/extensions/tools/schemas.ts

@@ -37,14 +37,7 @@ export const ReadFileLineRangeSchema = z
 				"Optional one-based ending line number to read through; use null or omit for the end of the file",
 			),
 	})
-	.refine(
-		({ start_line, end_line }) =>
-			start_line == null || end_line == null || start_line <= end_line,
-		{
-			message: "start_line must be less than or equal to end_line",
-			path: ["end_line"],
-		},
-	);
+	.describe("Optional inclusive one-based file line range");
 
 export const ReadFileRequestSchema = z
 	.object({
@@ -52,13 +45,8 @@ export const ReadFileRequestSchema = z
 		start_line: ReadFileLineRangeSchema.shape.start_line,
 		end_line: ReadFileLineRangeSchema.shape.end_line,
 	})
-	.refine(
-		({ start_line, end_line }) =>
-			start_line == null || end_line == null || start_line <= end_line,
-		{
-			message: "start_line must be less than or equal to end_line",
-			path: ["end_line"],
-		},
+	.describe(
+		"A file read request with optional inclusive one-based line bounds",
 	);
 
 /**
@@ -84,6 +72,9 @@ export const ReadFilesInputUnionSchema = z.union([
 	z.object({ files: ReadFileRequestSchema }),
 	z.object({ file_paths: z.array(AbsolutePath) }),
 	z.object({ file_paths: z.string() }),
+	z.object({ paths: z.array(z.union([AbsolutePath, ReadFileRequestSchema])) }),
+	z.object({ paths: ReadFileRequestSchema }),
+	z.object({ paths: z.string() }),
 ]);
 
 /**
@@ -126,6 +117,8 @@ export const RunCommandsInputSchema = z.object({
 export const RunCommandsInputUnionSchema = z.union([
 	RunCommandsInputSchema,
 	z.object({ commands: CommandInputSchema }),
+	z.object({ command: CommandInputSchema }),
+	z.object({ cmd: CommandInputSchema }),
 	z.array(z.string()),
 	z.string(),
 ]);
@@ -163,10 +156,12 @@ export const StructuredCommandsInputUnionSchema = z.union([
 	RunCommandsInputSchema,
 	StructuredCommandsInputSchema,
 	z.object({ commands: StructuredCommandEntrySchema }),
-	z.array(z.string()),
 	z.array(StructuredCommandInputSchema),
-	z.string(),
 	StructuredCommandInputSchema,
+	z.object({ command: CommandInputSchema }),
+	z.object({ cmd: CommandInputSchema }),
+	z.array(z.string()),
+	z.string(),
 ]);
 
 /**
@@ -213,7 +208,7 @@ export const EditFileInputSchema = z
 			.nullable()
 			.optional()
 			.describe(
-				"Optional one-based line index. When provided, the tool inserts new_text at that line instead of performing a replacement edit.",
+				"Optional positive one-based boundary line. When provided, the tool inserts new_text before that line instead of performing a replacement edit; use line_count + 1 to append at EOF.",
 			),
 	})
 	.describe(
@@ -228,10 +223,12 @@ export const ApplyPatchInputSchema = z
 		input: z
 			.string()
 			.min(1)
-			.describe("The apply_patch text payload, including patch instructions"),
+			.describe(
+				"The freeform apply_patch payload in the canonical patch grammar (e.g *** Begin Patch, *** Update File:, @@, and *** End Patch).",
+			),
 	})
 	.describe(
-		"Modify or create a text file by applying patches. Prefer using this tool for file edits over shell commands. IMPORTANT: large patches can time out, so use small chunks and multiple calls when possible.",
+		"Modify or create a text file by applying patches using the canonical apply_patch diff grammar. Prefer sending the patch body directly rather than wrapping it in shell syntax. IMPORTANT: large patches can time out, so use small chunks and multiple calls when possible.",
 	);
 export const ApplyPatchInputUnionSchema = z.union([
 	ApplyPatchInputSchema,

package/src/extensions/tools/team/delegated-agent.ts

@@ -1,4 +1,3 @@
-import { Agent } from "@clinebot/agents";
 import type {
 	AgentConfig,
 	AgentEvent,
@@ -10,6 +9,7 @@ import type {
 	ToolApprovalRequest,
 	ToolApprovalResult,
 } from "@clinebot/shared";
+import { SessionRuntime } from "../../../runtime/session-runtime-orchestrator";
 import {
 	buildSubAgentSystemPrompt,
 	buildTeammateSystemPrompt,
@@ -126,6 +126,11 @@ export function buildDelegatedAgentConfig(
 
 export function createDelegatedAgent(
 	options: BuildDelegatedAgentConfigOptions,
-): Agent {
-	return new Agent(buildDelegatedAgentConfig(options));
+): SessionRuntime {
+	const config = buildDelegatedAgentConfig(options);
+	const session = new SessionRuntime(config);
+	if (config.onEvent) {
+		session.subscribeEvents(config.onEvent);
+	}
+	return session;
 }

package/src/extensions/tools/team/multi-agent.ts

@@ -4,7 +4,6 @@
  * Utilities for orchestrating multiple agents working together.
  */
 
-import { type Agent, createAgent } from "@clinebot/agents";
 import {
 	type AgentConfig,
 	type AgentEvent,
@@ -33,6 +32,7 @@ import {
 	type TeamTaskStatus,
 } from "@clinebot/shared";
 import { nanoid } from "nanoid";
+import { SessionRuntime } from "../../../runtime/session-runtime-orchestrator";
 
 // Re-export shared types for backward compatibility
 export {
@@ -155,14 +155,26 @@ function isAbortLikeError(error: unknown): boolean {
 	);
 }
 
+function isIntentionalShutdownAbort(
+	member: TeamMemberState | undefined,
+	error: unknown,
+): boolean {
+	return member?.status === "stopped" && isAbortLikeError(error);
+}
+
 // =============================================================================
 // AgentTeam
 // =============================================================================
 
 const TEAMMATE_API_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+const RECOVERED_QUEUED_ACTIVITY = "recovered_queued";
+
+function buildRecoveredRunMessage(run: TeamRunRecord): string {
+	return `This is an automatic recovery of interrupted team run ${run.id}. The previous process stopped before completion. Continue the task safely, inspect the current workspace state before making changes, and avoid duplicating completed work.\n\n${run.message}`;
+}
 
 export class AgentTeam {
-	private agents: Map<string, Agent> = new Map();
+	private agents: Map<string, SessionRuntime> = new Map();
 	private configs: Map<string, TeamMemberConfig> = new Map();
 	private onTeamEvent?: (event: TeamEvent) => void;
 
@@ -196,7 +208,10 @@ export class AgentTeam {
 			},
 		};
 
-		const agent = createAgent(wrappedConfig);
+		const agent = new SessionRuntime(wrappedConfig);
+		if (wrappedConfig.onEvent) {
+			agent.subscribeEvents(wrappedConfig.onEvent);
+		}
 		this.agents.set(id, agent);
 		this.configs.set(id, config);
 	}
@@ -206,7 +221,7 @@ export class AgentTeam {
 		return this.agents.delete(id);
 	}
 
-	getAgent(id: string): Agent | undefined {
+	getAgent(id: string): SessionRuntime | undefined {
 		return this.agents.get(id);
 	}
 
@@ -497,7 +512,7 @@ export function createWorkerReviewerTeam(configs: {
 // =============================================================================
 
 interface TeamMemberState extends TeamMemberSnapshot {
-	agent?: Agent;
+	agent?: SessionRuntime;
 	runningCount: number;
 	lastMissionStep: number;
 	lastMissionAt: number;
@@ -522,6 +537,7 @@ export class AgentTeamsRuntime {
 	private readonly runs: Map<string, TeamRunRecord & { result?: AgentResult }> =
 		new Map();
 	private readonly runQueue: string[] = [];
+	private queuedRunDispatchTimer: ReturnType<typeof setTimeout> | undefined;
 	private readonly outcomes: Map<string, TeamOutcome> = new Map();
 	private readonly outcomeFragments: Map<string, TeamOutcomeFragment> =
 		new Map();
@@ -707,6 +723,7 @@ export class AgentTeamsRuntime {
 	}
 
 	hydrateState(state: TeamRuntimeState): void {
+		this.clearQueuedRunDispatchTimer();
 		this.tasks.clear();
 		for (const task of state.tasks) {
 			this.tasks.set(task.id, { ...task });
@@ -851,7 +868,10 @@ export class AgentTeamsRuntime {
 			},
 		};
 
-		const agent = createAgent(wrappedConfig);
+		const agent = new SessionRuntime(wrappedConfig);
+		if (wrappedConfig.onEvent) {
+			agent.subscribeEvents(wrappedConfig.onEvent);
+		}
 		const teammate: TeamMemberState = {
 			agentId,
 			role: "teammate",
@@ -1038,12 +1058,14 @@ export class AgentTeamsRuntime {
 				error: err,
 				messages: member.agent.getMessages(),
 			});
-			this.appendMissionLog({
-				agentId,
-				taskId: options?.taskId,
-				kind: "error",
-				summary: err.message,
-			});
+			if (!isIntentionalShutdownAbort(member, err)) {
+				this.appendMissionLog({
+					agentId,
+					taskId: options?.taskId,
+					kind: "error",
+					summary: err.message,
+				});
+			}
 			throw err;
 		} finally {
 			member.runningCount--;
@@ -1091,11 +1113,19 @@ export class AgentTeamsRuntime {
 	}
 
 	private dispatchQueuedRuns(): void {
+		this.clearQueuedRunDispatchTimer();
+		let nextDelayedAttemptAt: Date | undefined;
 		while (
 			this.countActiveRuns() < this.maxConcurrentRuns &&
 			this.runQueue.length > 0
 		) {
-			const nextRunIndex = this.selectNextQueuedRunIndex();
+			const nextRun = this.selectNextDispatchableQueuedRun();
+			nextDelayedAttemptAt = nextRun.nextDelayedAttemptAt;
+			const nextRunIndex = nextRun.index;
+			if (nextRunIndex < 0) {
+				this.scheduleQueuedRunDispatch(nextDelayedAttemptAt);
+				return;
+			}
 			const [runId] = this.runQueue.splice(nextRunIndex, 1);
 			const run = runId ? this.runs.get(runId) : undefined;
 			if (!run || run.status !== "queued") {
@@ -1103,22 +1133,53 @@ export class AgentTeamsRuntime {
 			}
 			void this.executeQueuedRun(run);
 		}
+		this.scheduleQueuedRunDispatch(nextDelayedAttemptAt);
 	}
 
-	private selectNextQueuedRunIndex(): number {
-		let selectedIndex = 0;
+	private selectNextDispatchableQueuedRun(): {
+		index: number;
+		nextDelayedAttemptAt?: Date;
+	} {
+		let selectedIndex = -1;
 		let bestPriority = Number.NEGATIVE_INFINITY;
+		let nextDelayedAttemptAt: Date | undefined;
+		const now = Date.now();
 		for (let index = 0; index < this.runQueue.length; index++) {
 			const run = this.runs.get(this.runQueue[index]);
 			if (!run || run.status !== "queued") {
 				continue;
 			}
+			if (run.nextAttemptAt && run.nextAttemptAt.getTime() > now) {
+				if (!nextDelayedAttemptAt || run.nextAttemptAt < nextDelayedAttemptAt) {
+					nextDelayedAttemptAt = run.nextAttemptAt;
+				}
+				continue;
+			}
 			if (run.priority > bestPriority) {
 				bestPriority = run.priority;
 				selectedIndex = index;
 			}
 		}
-		return selectedIndex;
+		return { index: selectedIndex, nextDelayedAttemptAt };
+	}
+
+	private scheduleQueuedRunDispatch(nextAttemptAt: Date | undefined): void {
+		if (!nextAttemptAt) {
+			return;
+		}
+		const delayMs = Math.max(0, nextAttemptAt.getTime() - Date.now());
+		this.queuedRunDispatchTimer = setTimeout(() => {
+			this.queuedRunDispatchTimer = undefined;
+			this.dispatchQueuedRuns();
+		}, delayMs);
+	}
+
+	private clearQueuedRunDispatchTimer(): void {
+		if (!this.queuedRunDispatchTimer) {
+			return;
+		}
+		clearTimeout(this.queuedRunDispatchTimer);
+		this.queuedRunDispatchTimer = undefined;
 	}
 
 	private countActiveRuns(): number {
@@ -1134,6 +1195,8 @@ export class AgentTeamsRuntime {
 	private async executeQueuedRun(
 		run: TeamRunRecord & { result?: AgentResult },
 	): Promise<void> {
+		const recoveredRun = run.currentActivity === RECOVERED_QUEUED_ACTIVITY;
+		run.nextAttemptAt = undefined;
 		run.status = "running";
 		run.startedAt = new Date();
 		run.heartbeatAt = new Date();
@@ -1148,7 +1211,10 @@ export class AgentTeamsRuntime {
 		}, 2000);
 
 		try {
-			const result = await this.routeToTeammate(run.agentId, run.message, {
+			const runMessage = recoveredRun
+				? buildRecoveredRunMessage(run)
+				: run.message;
+			const result = await this.routeToTeammate(run.agentId, runMessage, {
 				taskId: run.taskId,
 				continueConversation: run.continueConversation,
 			});
@@ -1164,7 +1230,16 @@ export class AgentTeamsRuntime {
 					: String(error ?? "Unknown error");
 			run.error = message;
 			run.endedAt = new Date();
-			if (run.retryCount < run.maxRetries) {
+			const member = this.members.get(run.agentId);
+			if (isIntentionalShutdownAbort(member, error)) {
+				run.status = "cancelled";
+				run.currentActivity = "cancelled";
+				this.emitEvent({
+					type: TeamMessageType.RunCancelled,
+					run: { ...run },
+					reason: message,
+				});
+			} else if (run.retryCount < run.maxRetries) {
 				run.retryCount++;
 				run.status = "queued";
 				run.nextAttemptAt = new Date(
@@ -1215,7 +1290,7 @@ export class AgentTeamsRuntime {
 		if (!run) {
 			throw new Error(`Run "${runId}" was not found`);
 		}
-		while (run.status === "running") {
+		while (run.status === "queued" || run.status === "running") {
 			await sleep(pollIntervalMs);
 		}
 		return { ...run };
@@ -1256,6 +1331,45 @@ export class AgentTeamsRuntime {
 		return { ...run };
 	}
 
+	recoverActiveRuns(reason = "runtime_recovered"): TeamRunRecord[] {
+		const recovered: TeamRunRecord[] = [];
+		for (const run of this.runs.values()) {
+			if (!["queued", "running"].includes(run.status)) {
+				continue;
+			}
+
+			const member = this.members.get(run.agentId);
+			if (!member || member.role !== "teammate" || !member.agent) {
+				run.status = "interrupted";
+				run.error = "teammate_unavailable_after_recovery";
+				run.endedAt = new Date();
+				run.currentActivity = "interrupted";
+				this.emitEvent({
+					type: TeamMessageType.RunInterrupted,
+					run: { ...run },
+					reason: run.error,
+				});
+				continue;
+			}
+
+			const now = new Date();
+			run.status = "queued";
+			run.error = undefined;
+			run.endedAt = undefined;
+			run.heartbeatAt = now;
+			run.lastProgressAt = now;
+			run.lastProgressMessage = reason;
+			run.currentActivity = RECOVERED_QUEUED_ACTIVITY;
+			if (!this.runQueue.includes(run.id)) {
+				this.runQueue.push(run.id);
+			}
+			recovered.push({ ...run });
+			this.emitEvent({ type: TeamMessageType.RunQueued, run: { ...run } });
+		}
+		this.dispatchQueuedRuns();
+		return recovered;
+	}
+
 	markStaleRunsInterrupted(reason = "runtime_recovered"): TeamRunRecord[] {
 		const interrupted: TeamRunRecord[] = [];
 		for (const run of this.runs.values()) {
@@ -1274,6 +1388,7 @@ export class AgentTeamsRuntime {
 			});
 		}
 		this.runQueue.length = 0;
+		this.clearQueuedRunDispatchTimer();
 		return interrupted;
 	}
 
@@ -1513,6 +1628,7 @@ export class AgentTeamsRuntime {
 		this.missionLog.length = 0;
 		this.runs.clear();
 		this.runQueue.length = 0;
+		this.clearQueuedRunDispatchTimer();
 		this.outcomes.clear();
 		this.outcomeFragments.clear();