@xopcai/xopc 0.0.180 → 0.0.187

package/dist/src/gateway/hono/routes/work.js

@@ -1,207 +0,0 @@
-import { GoalService } from "../../../goals/goal-service.js";
-import { OutcomeRepository } from "../../../work/outcome-repository.js";
-import "../../../goals/index.js";
-import { OutcomeActionRequestSchema, OutcomeUserStatusSchema } from "../../../../packages/gateway-contract/src/outcomes.js";
-import { ProjectMonitoringUpdateSchema, WorkIntakeConfirmRequestSchema, WorkIntakeCreateRequestSchema } from "../../../../packages/gateway-contract/src/work-intake.js";
-import { OutcomeReceiptService } from "../../../work/outcome-receipt-service.js";
-import { ProjectMonitoringService } from "../../../work/project-monitoring-service.js";
-import { ProjectOperatingViewService } from "../../../work/project-operating-view-service.js";
-import { WorkIntakeService } from "../../../work/work-intake-service.js";
-import { WorkValueMetricsService } from "../../../work/work-value-metrics-service.js";
-//#region src/gateway/hono/routes/work.ts
-function registerWorkRoutes(authenticated, deps) {
-	const intake = new WorkIntakeService(deps.service.projects, { enqueue: (goalId, options) => deps.service.enqueueGoalRun(goalId, options) });
-	const operatingViews = new ProjectOperatingViewService(deps.service.projects, deps.service.workItems);
-	const monitoring = new ProjectMonitoringService();
-	const metrics = new WorkValueMetricsService();
-	const outcomes = new OutcomeRepository();
-	const receipts = new OutcomeReceiptService();
-	const goals = new GoalService();
-	authenticated.get("/api/outcomes", (c) => {
-		const status = OutcomeUserStatusSchema.safeParse(c.req.query("status"));
-		const rawLimit = Number(c.req.query("limit") ?? 50);
-		const limit = Number.isFinite(rawLimit) ? rawLimit : 50;
-		return c.json({
-			ok: true,
-			items: outcomes.list({
-				...status.success ? { status: status.data } : {},
-				limit
-			})
-		});
-	});
-	authenticated.get("/api/outcomes/:id", (c) => {
-		const outcome = outcomes.get(c.req.param("id"));
-		return outcome ? c.json({
-			ok: true,
-			outcome,
-			receipts: receipts.list({
-				outcomeId: outcome.id,
-				limit: 100
-			})
-		}) : c.json({
-			ok: false,
-			error: "Outcome not found"
-		}, 404);
-	});
-	authenticated.post("/api/outcomes/:id/actions", deps.strictRateLimitMiddleware, async (c) => {
-		const outcome = outcomes.get(c.req.param("id"));
-		if (!outcome) return c.json({
-			ok: false,
-			error: "Outcome not found"
-		}, 404);
-		const parsed = OutcomeActionRequestSchema.safeParse(await c.req.json().catch(() => ({})));
-		if (!parsed.success) return c.json({
-			ok: false,
-			error: "Invalid outcome action"
-		}, 400);
-		const goalId = outcomes.listLinks(outcome.id).find((link) => link.kind === "goal")?.id;
-		const goal = goalId ? goals.get(goalId) : void 0;
-		if (parsed.data.action === "pause") {
-			if (goal && goal.status !== "done" && goal.status !== "archived" && goal.status !== "paused") goals.pause(goal.id, "Paused by the user");
-			return c.json({
-				ok: true,
-				outcome: outcomes.updateState({
-					id: outcome.id,
-					userStatus: "running",
-					internalStatus: "paused"
-				})
-			});
-		}
-		if (parsed.data.action === "cancel") {
-			if (goal && goal.status !== "done" && goal.status !== "archived") goals.pause(goal.id, "Cancelled by the user");
-			return c.json({
-				ok: true,
-				outcome: outcomes.updateState({
-					id: outcome.id,
-					userStatus: "completed",
-					internalStatus: "cancelled"
-				})
-			});
-		}
-		if (!goal) return c.json({
-			ok: false,
-			error: "Outcome has no executable goal"
-		}, 409);
-		if (goal.status === "done" || goal.status === "archived") goals.reopen(goal.id);
-		else if (goal.status !== "active") goals.resume(goal.id);
-		const queued = deps.service.enqueueGoalRun(goal.id, {
-			source: "api",
-			executionContext: {
-				outcomeId: outcome.id,
-				triggerKind: parsed.data.action === "resume" ? "retry" : "user"
-			}
-		});
-		return c.json({
-			ok: true,
-			outcome: outcomes.updateState({
-				id: outcome.id,
-				userStatus: "running",
-				internalStatus: "continuing"
-			}),
-			queued
-		});
-	});
-	authenticated.post("/api/work/intakes", deps.strictRateLimitMiddleware, async (c) => {
-		const parsed = WorkIntakeCreateRequestSchema.safeParse(await c.req.json().catch(() => ({})));
-		if (!parsed.success) return c.json({
-			ok: false,
-			error: "Invalid work intake request"
-		}, 400);
-		try {
-			const proposal = intake.propose({ ...parsed.data });
-			return c.json({
-				ok: true,
-				proposal
-			}, 201);
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: error instanceof Error ? error.message : String(error)
-			}, 400);
-		}
-	});
-	authenticated.post("/api/work/intakes/:id/confirm", deps.strictRateLimitMiddleware, async (c) => {
-		const parsed = WorkIntakeConfirmRequestSchema.safeParse(await c.req.json().catch(() => ({})));
-		if (!parsed.success) return c.json({
-			ok: false,
-			error: "Invalid work intake confirmation"
-		}, 400);
-		try {
-			const work = intake.confirm({
-				proposalId: c.req.param("id"),
-				...parsed.data
-			});
-			return work ? c.json({
-				ok: true,
-				work
-			}, 201) : c.json({
-				ok: false,
-				error: "Work intake expired or was not found"
-			}, 404);
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: error instanceof Error ? error.message : String(error)
-			}, 400);
-		}
-	});
-	authenticated.get("/api/projects/:projectId/operating-view", (c) => {
-		const view = operatingViews.get(c.req.param("projectId"));
-		return view ? c.json({
-			ok: true,
-			view
-		}) : c.json({
-			ok: false,
-			error: "Project not found"
-		}, 404);
-	});
-	authenticated.get("/api/work/metrics", (c) => c.json({
-		ok: true,
-		metrics: metrics.get()
-	}));
-	authenticated.get("/api/projects/:projectId/monitoring", (c) => {
-		const projectId = c.req.param("projectId");
-		if (!deps.service.projects.get(projectId)) return c.json({
-			ok: false,
-			error: "Project not found"
-		}, 404);
-		return c.json({
-			ok: true,
-			policy: monitoring.get(projectId)
-		});
-	});
-	authenticated.patch("/api/projects/:projectId/monitoring", deps.strictRateLimitMiddleware, async (c) => {
-		const projectId = c.req.param("projectId");
-		if (!deps.service.projects.get(projectId)) return c.json({
-			ok: false,
-			error: "Project not found"
-		}, 404);
-		const parsed = ProjectMonitoringUpdateSchema.safeParse(await c.req.json().catch(() => ({})));
-		if (!parsed.success) return c.json({
-			ok: false,
-			error: "Invalid monitoring policy"
-		}, 400);
-		const current = monitoring.get(projectId);
-		try {
-			const policy = monitoring.configure({
-				projectId,
-				mode: parsed.data.mode ?? current.mode,
-				quietHours: parsed.data.quietHours === null ? void 0 : parsed.data.quietHours ?? current.quietHours,
-				allowedActions: parsed.data.allowedActions ?? current.allowedActions,
-				confidenceThreshold: parsed.data.confidenceThreshold ?? current.confidenceThreshold,
-				scenarios: parsed.data.scenarios ?? (current.configured ? current.scenarios : void 0)
-			});
-			return c.json({
-				ok: true,
-				policy
-			});
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: error instanceof Error ? error.message : String(error)
-			}, 400);
-		}
-	});
-}
-//#endregion
-export { registerWorkRoutes };

package/dist/src/goals/goal-notifications.d.ts

@@ -1,31 +0,0 @@
-import type { Config } from '../config/schema.js';
-import type { SessionMetadata } from '../session/index.js';
-export type GoalNotificationEvent = 'done' | 'blocked' | 'needs_input' | 'queue_failed' | 'queue_retry' | 'queue_succeeded' | 'queue_skipped';
-export interface GoalNotificationTarget {
-    channel: string;
-    chatId: string;
-    accountId?: string;
-    threadId?: string | number;
-    silent?: boolean;
-}
-export interface GoalNotificationSendInput extends GoalNotificationTarget {
-    text: string;
-}
-export interface GoalNotificationServiceOptions {
-    getConfig: () => Config;
-    getSessionMetadata?: (sessionKey: string) => Promise<SessionMetadata | null>;
-    send: (input: GoalNotificationSendInput) => Promise<void>;
-}
-export declare class GoalNotificationService {
-    private readonly opts;
-    private readonly goals;
-    private readonly sentKeys;
-    constructor(opts: GoalNotificationServiceOptions);
-    handleGatewayEvent(type: string, payload: unknown): void;
-    private handleQueueUpdated;
-    private handleStatusUpdated;
-    private notify;
-    private resolveTargets;
-    private parseQueueItem;
-    private isGoal;
-}

package/dist/src/goals/goal-notifications.js

@@ -1,157 +0,0 @@
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-import { GoalService } from "./goal-service.js";
-//#region src/goals/goal-notifications.ts
-init_logger();
-const log = createLogger("GoalNotifications");
-function eventForQueueStatus(status) {
-	if (status === "failed") return "queue_failed";
-	if (status === "retry_waiting") return "queue_retry";
-	if (status === "succeeded") return "queue_succeeded";
-	if (status === "skipped") return "queue_skipped";
-	return null;
-}
-function eventForGoalStatus(status) {
-	if (status === "done" || status === "blocked" || status === "needs_input") return status;
-	return null;
-}
-function targetKey(target) {
-	return [
-		target.channel,
-		target.chatId,
-		target.accountId ?? "",
-		target.threadId ?? ""
-	].join("\0");
-}
-function formatGoalNotification(event, goal, opts) {
-	const lines = [`${{
-		done: "Goal completed",
-		blocked: "Goal blocked",
-		needs_input: "Goal needs input",
-		queue_failed: "Goal run failed",
-		queue_retry: "Goal run retry scheduled",
-		queue_succeeded: "Goal run finished",
-		queue_skipped: "Goal run skipped"
-	}[event]}: ${goal.title}`];
-	if (goal.blockedReason) lines.push(`Reason: ${goal.blockedReason}`);
-	if (goal.nextAction) lines.push(`Next: ${goal.nextAction}`);
-	if (goal.latestRun?.reason && goal.latestRun.reason !== goal.blockedReason) lines.push(`Run: ${goal.latestRun.reason}`);
-	if (opts?.queueItem?.lastError) lines.push(`Queue: ${opts.queueItem.lastError}`);
-	const progress = goal.checklist.length ? goal.checklist.filter((it) => it.status === "completed" || it.status === "impossible").length : 0;
-	if (goal.checklist.length) lines.push(`Checklist: ${progress}/${goal.checklist.length}`);
-	lines.push(`Turns: ${goal.turnsUsed}/${goal.maxTurns}`);
-	return lines.join("\n");
-}
-var GoalNotificationService = class {
-	goals = new GoalService();
-	sentKeys = /* @__PURE__ */ new Set();
-	constructor(opts) {
-		this.opts = opts;
-	}
-	handleGatewayEvent(type, payload) {
-		if (type === "goal.queue.updated") {
-			this.handleQueueUpdated(payload).catch((err) => {
-				log.warn({ err }, "Goal queue notification failed");
-			});
-			return;
-		}
-		if (type === "goal.status.updated") this.handleStatusUpdated(payload).catch((err) => {
-			log.warn({ err }, "Goal status notification failed");
-		});
-	}
-	async handleQueueUpdated(payload) {
-		const item = this.parseQueueItem(payload);
-		if (!item) return;
-		const event = eventForQueueStatus(item.status);
-		if (!event) return;
-		const goal = this.goals.get(item.goalId);
-		if (!goal) return;
-		await this.notify(event, goal, {
-			queueItem: item,
-			eventKey: `${item.id}:${item.status}:${item.attempts}`
-		});
-	}
-	async handleStatusUpdated(payload) {
-		if (!payload || typeof payload !== "object") return;
-		const rec = payload;
-		const goal = this.isGoal(rec.goal) ? rec.goal : typeof rec.goalId === "string" ? this.goals.get(rec.goalId) : null;
-		if (!goal) return;
-		const status = typeof rec.status === "string" ? rec.status : goal.status;
-		const event = eventForGoalStatus(status);
-		if (!event) return;
-		if (rec.previousStatus === status) return;
-		await this.notify(event, goal, { eventKey: `${goal.id}:${event}:${goal.updatedAt}` });
-	}
-	async notify(event, goal, opts) {
-		const policy = this.opts.getConfig().goals?.notifications;
-		if (!policy?.enabled) return;
-		if (!policy.events.includes(event)) return;
-		const targets = await this.resolveTargets(event, goal);
-		if (targets.length === 0) return;
-		const text = formatGoalNotification(event, goal, { queueItem: opts?.queueItem });
-		for (const target of targets) {
-			const dedupeKey = `${opts?.eventKey ?? `${goal.id}:${event}`}:${targetKey(target)}`;
-			if (this.sentKeys.has(dedupeKey)) continue;
-			this.sentKeys.add(dedupeKey);
-			await this.opts.send({
-				...target,
-				text
-			}).catch((err) => {
-				this.sentKeys.delete(dedupeKey);
-				throw err;
-			});
-		}
-	}
-	async resolveTargets(event, goal) {
-		const policy = this.opts.getConfig().goals?.notifications;
-		if (!policy?.enabled) return [];
-		const byKey = /* @__PURE__ */ new Map();
-		if (policy.includeLinkedSessions !== false && goal.activeSessionKey && this.opts.getSessionMetadata) {
-			const routing = (await this.opts.getSessionMetadata(goal.activeSessionKey).catch((err) => {
-				log.warn({
-					err,
-					sessionKey: goal.activeSessionKey,
-					goalId: goal.id
-				}, "Failed to load linked session metadata for goal notification");
-				return null;
-			}))?.routing;
-			if (routing && policy.channels.includes(routing.source)) {
-				const target = {
-					channel: routing.source,
-					chatId: routing.peerId,
-					accountId: routing.accountId,
-					...routing.threadId ? { threadId: routing.threadId } : {}
-				};
-				byKey.set(targetKey(target), target);
-			}
-		}
-		for (const target of policy.targets ?? []) {
-			const events = target.events;
-			if (events && !events.includes(event)) continue;
-			const normalized = {
-				channel: target.channel,
-				chatId: target.chatId,
-				...target.accountId ? { accountId: target.accountId } : {},
-				...target.threadId != null ? { threadId: target.threadId } : {},
-				...target.silent != null ? { silent: target.silent } : {}
-			};
-			byKey.set(targetKey(normalized), normalized);
-		}
-		return [...byKey.values()];
-	}
-	parseQueueItem(payload) {
-		if (!payload || typeof payload !== "object") return null;
-		const item = payload.item;
-		if (!item || typeof item !== "object") return null;
-		const rec = item;
-		if (typeof rec.id !== "string" || typeof rec.goalId !== "string" || typeof rec.status !== "string") return null;
-		return rec;
-	}
-	isGoal(value) {
-		if (!value || typeof value !== "object") return false;
-		const rec = value;
-		return typeof rec.id === "string" && typeof rec.title === "string" && Array.isArray(rec.checklist);
-	}
-};
-//#endregion
-export { GoalNotificationService };

package/dist/src/goals/goal-queue-store.d.ts

@@ -1,18 +0,0 @@
-import type { GoalQueueItemSnapshot, GoalQueueStatus } from './goal-queue-types.js';
-import type { UserTurnInput } from '../gateway/user-turn-input.js';
-export declare class GoalQueueStore {
-    enqueue(input: {
-        goalId: string;
-        userTurn?: UserTurnInput;
-        executionContext?: GoalQueueItemSnapshot['executionContext'];
-        maxRetries: number;
-        source: GoalQueueItemSnapshot['source'];
-    }): GoalQueueItemSnapshot;
-    claimNext(now?: number): GoalQueueItemSnapshot | null;
-    markRetry(itemId: string, error: string, nextRunAt: number): GoalQueueItemSnapshot | null;
-    markFinished(itemId: string, status: GoalQueueStatus, error?: string): GoalQueueItemSnapshot | null;
-    setSessionKey(itemId: string, sessionKey: string): GoalQueueItemSnapshot | null;
-    list(limit?: number): GoalQueueItemSnapshot[];
-    resetRunningToRetry(reason?: string): number;
-    private update;
-}

package/dist/src/goals/goal-queue-store.js

@@ -1,133 +0,0 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { randomUUID } from "node:crypto";
-//#region src/goals/goal-queue-store.ts
-function parsePayload(raw) {
-	try {
-		const parsed = JSON.parse(raw);
-		return parsed && typeof parsed === "object" ? parsed : {};
-	} catch {
-		return {};
-	}
-}
-function rowToSnapshot(row) {
-	const payload = parsePayload(row.payload_json);
-	return {
-		id: row.queue_id,
-		goalId: row.goal_id,
-		status: row.status,
-		attempts: row.attempts,
-		maxRetries: row.max_retries,
-		enqueuedAt: row.enqueued_at,
-		startedAt: row.started_at ?? void 0,
-		finishedAt: row.finished_at ?? void 0,
-		nextRunAt: row.next_run_at ?? void 0,
-		sessionKey: row.session_key ?? void 0,
-		userTurn: payload.userTurn,
-		executionContext: payload.executionContext,
-		lastError: row.last_error ?? void 0,
-		source: row.source
-	};
-}
-var GoalQueueStore = class {
-	enqueue(input) {
-		return runSqliteWriteTransaction((db) => {
-			const existing = db.prepare(`SELECT * FROM goal_queue
-           WHERE goal_id = ?
-             AND status IN ('queued', 'running', 'retry_waiting')
-           ORDER BY enqueued_at DESC
-           LIMIT 1`).get(input.goalId);
-			if (existing) return rowToSnapshot(existing);
-			const now = Date.now();
-			const row = {
-				queue_id: randomUUID(),
-				goal_id: input.goalId,
-				status: "queued",
-				payload_json: JSON.stringify({
-					userTurn: input.userTurn,
-					executionContext: input.executionContext
-				}),
-				attempts: 0,
-				max_retries: input.maxRetries,
-				enqueued_at: now,
-				started_at: null,
-				finished_at: null,
-				next_run_at: null,
-				session_key: null,
-				last_error: null,
-				source: input.source
-			};
-			db.prepare(`INSERT INTO goal_queue (
-          queue_id, goal_id, status, payload_json, attempts, max_retries,
-          enqueued_at, source
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(row.queue_id, row.goal_id, row.status, row.payload_json, row.attempts, row.max_retries, row.enqueued_at, row.source);
-			return rowToSnapshot(row);
-		});
-	}
-	claimNext(now = Date.now()) {
-		return runSqliteWriteTransaction((db) => {
-			const row = db.prepare(`SELECT * FROM goal_queue
-           WHERE status = 'queued'
-              OR (status = 'retry_waiting' AND COALESCE(next_run_at, 0) <= ?)
-           ORDER BY enqueued_at ASC
-           LIMIT 1`).get(now);
-			if (!row) return null;
-			const startedAt = Date.now();
-			db.prepare(`UPDATE goal_queue
-         SET status = 'running',
-             started_at = ?,
-             attempts = attempts + 1,
-             last_error = NULL
-         WHERE queue_id = ?`).run(startedAt, row.queue_id);
-			return rowToSnapshot(db.prepare(`SELECT * FROM goal_queue WHERE queue_id = ?`).get(row.queue_id));
-		});
-	}
-	markRetry(itemId, error, nextRunAt) {
-		return this.update(itemId, {
-			status: "retry_waiting",
-			next_run_at: nextRunAt,
-			last_error: error,
-			finished_at: null
-		});
-	}
-	markFinished(itemId, status, error) {
-		return this.update(itemId, {
-			status,
-			finished_at: Date.now(),
-			last_error: error ?? null
-		});
-	}
-	setSessionKey(itemId, sessionKey) {
-		return this.update(itemId, { session_key: sessionKey });
-	}
-	list(limit = 200) {
-		const safeLimit = Math.min(500, Math.max(1, Math.floor(limit)));
-		return getSqliteDatabase().prepare(`SELECT * FROM goal_queue ORDER BY enqueued_at DESC LIMIT ?`).all(safeLimit).map(rowToSnapshot);
-	}
-	resetRunningToRetry(reason = "Gateway restarted during goal run") {
-		return runSqliteWriteTransaction((db) => {
-			const result = db.prepare(`UPDATE goal_queue
-           SET status = 'retry_waiting',
-               next_run_at = ?,
-               last_error = ?
-           WHERE status = 'running'`).run(Date.now(), reason);
-			return Number(result.changes ?? 0);
-		});
-	}
-	update(itemId, patch) {
-		return runSqliteWriteTransaction((db) => {
-			const row = db.prepare(`SELECT * FROM goal_queue WHERE queue_id = ?`).get(itemId);
-			if (!row) return null;
-			const next = {
-				...row,
-				...patch
-			};
-			db.prepare(`UPDATE goal_queue SET
-          status = ?, attempts = ?, started_at = ?, finished_at = ?,
-          next_run_at = ?, session_key = ?, last_error = ?
-         WHERE queue_id = ?`).run(next.status, next.attempts, next.started_at, next.finished_at, next.next_run_at, next.session_key, next.last_error, itemId);
-			return rowToSnapshot(db.prepare(`SELECT * FROM goal_queue WHERE queue_id = ?`).get(itemId));
-		});
-	}
-};
-//#endregion
-export { GoalQueueStore };

package/dist/src/goals/goal-queue-types.d.ts

@@ -1,42 +0,0 @@
-import type { GoalWithDetails } from './types.js';
-import type { UserTurnInput } from '../gateway/user-turn-input.js';
-export type GoalQueueStatus = 'queued' | 'running' | 'retry_waiting' | 'succeeded' | 'failed' | 'skipped';
-export interface GoalRunExecutionContext {
-    outcomeId?: string;
-    workItemId?: string;
-    contextTraceId?: string;
-    parentRunId?: string;
-    triggerKind: 'user' | 'schedule' | 'webhook' | 'proactive' | 'retry';
-}
-export interface GoalQueueItemSnapshot {
-    id: string;
-    goalId: string;
-    status: GoalQueueStatus;
-    attempts: number;
-    maxRetries: number;
-    enqueuedAt: number;
-    startedAt?: number;
-    finishedAt?: number;
-    nextRunAt?: number;
-    sessionKey?: string;
-    userTurn?: UserTurnInput;
-    executionContext?: GoalRunExecutionContext;
-    lastError?: string;
-    source: 'api' | 'cron' | 'workflow' | 'system';
-}
-export interface GoalRunnerOptions {
-    maxConcurrent?: number;
-    defaultMaxRetries?: number;
-    retryBaseMs?: number;
-    ensureSession: (goal: GoalWithDetails, context?: GoalRunExecutionContext) => Promise<string>;
-    bindExecutionContext?: (sessionKey: string, goal: GoalWithDetails, context?: GoalRunExecutionContext) => Promise<void>;
-    hasActiveRun: (sessionKey: string) => boolean;
-    runTurn: (sessionKey: string, userTurn: UserTurnInput) => Promise<void>;
-    emit?: (type: string, payload: unknown) => void;
-}
-export interface EnqueueGoalRunOptions {
-    userTurn?: UserTurnInput;
-    maxRetries?: number;
-    source?: GoalQueueItemSnapshot['source'];
-    executionContext?: GoalRunExecutionContext;
-}

package/dist/src/goals/goal-queue-types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/goals/goal-runner.d.ts

@@ -1,17 +0,0 @@
-import type { EnqueueGoalRunOptions, GoalQueueItemSnapshot, GoalRunnerOptions } from './goal-queue-types.js';
-export declare class GoalRunner {
-    private readonly opts;
-    private readonly goals;
-    private readonly store;
-    private active;
-    private pumpTimer;
-    constructor(opts: GoalRunnerOptions);
-    enqueue(goalId: string, options?: EnqueueGoalRunOptions): GoalQueueItemSnapshot;
-    snapshot(): GoalQueueItemSnapshot[];
-    private schedulePump;
-    private pump;
-    private runItem;
-    private retry;
-    private finish;
-    private emit;
-}