@xopcai/xopc 0.0.180 → 0.0.187

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

@@ -1,153 +0,0 @@
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-import { GoalService } from "./goal-service.js";
-import { GoalQueueStore } from "./goal-queue-store.js";
-import { mediaRefsToUserTurnAttachments } from "../gateway/user-turn-input.js";
-import { OutcomeRepository } from "../work/outcome-repository.js";
-//#region src/goals/goal-runner.ts
-init_logger();
-const log = createLogger("GoalRunner");
-function terminalGoalStatus(status) {
-	return status === "done" || status === "archived";
-}
-function buildInitialGoalTurn(goal) {
-	const context = goal.contextMessage;
-	const contract = new OutcomeRepository().getContract(goal.outcomeId, goal.outcomeContractVersion);
-	const parts = [`Outcome:\n${contract?.objective ?? goal.title}`];
-	if (contract?.constraints.length) parts.push(`Constraints:\n${contract.constraints.map((item) => `- ${item}`).join("\n")}`);
-	if (contract?.deliverables.length) parts.push(`Deliverables:\n${contract.deliverables.map((item) => `- ${item}`).join("\n")}`);
-	if (context?.text.trim()) parts.push(`Context:\n${context.text.trim()}`);
-	if (goal.checklist.length > 0) parts.push(`Acceptance criteria:\n${goal.checklist.map((item, index) => `${index + 1}. ${item.text}`).join("\n")}`);
-	return {
-		text: parts.join("\n\n"),
-		attachments: mediaRefsToUserTurnAttachments(context?.attachments),
-		clientCreatedAtMs: Date.now()
-	};
-}
-function buildFollowupGoalTurn(goal) {
-	return {
-		text: goal.nextAction || goal.title,
-		clientCreatedAtMs: Date.now()
-	};
-}
-var GoalRunner = class {
-	goals = new GoalService();
-	store = new GoalQueueStore();
-	active = 0;
-	pumpTimer = null;
-	constructor(opts) {
-		this.opts = opts;
-		this.store.resetRunningToRetry();
-		this.schedulePump(0);
-	}
-	enqueue(goalId, options = {}) {
-		const item = this.store.enqueue({
-			goalId,
-			maxRetries: Math.max(0, Math.floor(options.maxRetries ?? this.opts.defaultMaxRetries ?? 2)),
-			userTurn: options.userTurn && (options.userTurn.text.trim() || options.userTurn.attachments?.length) ? {
-				...options.userTurn,
-				text: options.userTurn.text.trim(),
-				clientCreatedAtMs: options.userTurn.clientCreatedAtMs ?? Date.now()
-			} : void 0,
-			source: options.source ?? "api",
-			executionContext: options.executionContext
-		});
-		this.emit("goal.queue.updated", item);
-		this.schedulePump(0);
-		return item;
-	}
-	snapshot() {
-		return this.store.list();
-	}
-	schedulePump(delayMs) {
-		if (this.pumpTimer) return;
-		this.pumpTimer = setTimeout(() => {
-			this.pumpTimer = null;
-			this.pump();
-		}, delayMs);
-	}
-	async pump() {
-		const maxConcurrent = Math.max(1, Math.floor(this.opts.maxConcurrent ?? 1));
-		while (this.active < maxConcurrent) {
-			const item = this.store.claimNext();
-			if (!item) break;
-			this.active += 1;
-			this.runItem(item).finally(() => {
-				this.active -= 1;
-				this.schedulePump(0);
-			});
-		}
-		const nextRetry = this.store.list().filter((item) => item.status === "retry_waiting" && item.nextRunAt).sort((a, b) => (a.nextRunAt ?? 0) - (b.nextRunAt ?? 0))[0];
-		if (nextRetry) this.schedulePump(Math.max(0, (nextRetry.nextRunAt ?? Date.now()) - Date.now()));
-	}
-	async runItem(item) {
-		this.emit("goal.queue.updated", item);
-		try {
-			const goal = this.goals.get(item.goalId);
-			if (!goal) {
-				this.finish(item, "failed", "Goal not found");
-				return;
-			}
-			if (terminalGoalStatus(goal.status)) {
-				this.finish(item, "skipped", `Goal is ${goal.status}`);
-				return;
-			}
-			const activeGoal = goal.status === "paused" || goal.status === "blocked" || goal.status === "needs_input" ? this.goals.resume(goal.id) : goal;
-			if (!activeGoal) {
-				this.finish(item, "failed", "Goal not found");
-				return;
-			}
-			const sessionKey = activeGoal.activeSessionKey ?? await this.opts.ensureSession(activeGoal, item.executionContext);
-			item = this.store.setSessionKey(item.id, sessionKey) ?? {
-				...item,
-				sessionKey
-			};
-			await this.opts.bindExecutionContext?.(sessionKey, activeGoal, item.executionContext);
-			if (this.opts.hasActiveRun(sessionKey)) {
-				this.retry(item, "Goal session already has an active run");
-				return;
-			}
-			const userTurn = item.userTurn ?? (activeGoal.turnsUsed === 0 ? buildInitialGoalTurn(activeGoal) : buildFollowupGoalTurn(activeGoal));
-			await this.opts.runTurn(sessionKey, userTurn);
-			this.finish(item, "succeeded");
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			if (item.attempts <= item.maxRetries) this.retry(item, message);
-			else this.finish(item, "failed", message);
-		}
-	}
-	retry(item, error) {
-		const base = Math.max(1e3, this.opts.retryBaseMs ?? 5e3);
-		item.status = "retry_waiting";
-		item.lastError = error;
-		item.nextRunAt = Date.now() + base * 2 ** Math.max(0, item.attempts - 1);
-		item = this.store.markRetry(item.id, error, item.nextRunAt) ?? item;
-		log.warn({
-			goalId: item.goalId,
-			attempts: item.attempts,
-			nextRunAt: item.nextRunAt,
-			errorMessage: error
-		}, `Goal run queued for retry: ${error}`);
-		this.emit("goal.queue.updated", item);
-		this.schedulePump(Math.max(0, item.nextRunAt - Date.now()));
-	}
-	finish(item, status, error) {
-		item = this.store.markFinished(item.id, status, error) ?? {
-			...item,
-			status,
-			finishedAt: Date.now(),
-			lastError: error
-		};
-		if (status === "failed") log.warn({
-			goalId: item.goalId,
-			attempts: item.attempts,
-			errorMessage: error
-		}, `Goal run failed: ${error}`);
-		this.emit("goal.queue.updated", item);
-	}
-	emit(type, item) {
-		this.opts.emit?.(type, { item: { ...item } });
-	}
-};
-//#endregion
-export { GoalRunner };

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

@@ -1,87 +0,0 @@
-import type { Config } from '../config/schema.js';
-import { GoalStore } from './goal-store.js';
-import type { CreateGoalInput, Goal, GoalChecklistAddedBy, GoalChecklistStatus, GoalContextAttachment, GoalJudgeDecision, GoalListQuery, GoalSource, GoalStatus, GoalUiLocale, GoalWithDetails } from './types.js';
-export interface GoalCompletionReadiness {
-    ready: boolean;
-    pendingCriteria: string[];
-}
-export declare class GoalService {
-    private readonly store;
-    constructor(store?: GoalStore);
-    create(input: Omit<CreateGoalInput, 'maxTurns' | 'agentId'> & {
-        maxTurns?: number;
-        agentId?: string;
-        config?: Config;
-    }): Goal;
-    get(goalId: string): GoalWithDetails | null;
-    getActiveForSession(sessionKey: string): GoalWithDetails | null;
-    list(query?: GoalListQuery): GoalWithDetails[];
-    setContextMessage(input: {
-        goalId: string;
-        text: string;
-        attachments?: GoalContextAttachment[];
-    }): GoalWithDetails | null;
-    update(goalId: string, patch: Partial<Pick<Goal, 'title' | 'description' | 'priority' | 'deadlineAt' | 'maxTurns' | 'judgeModelRef' | 'nextAction' | 'blockedReason' | 'activeSessionKey' | 'uiLocale' | 'projectId'>>): GoalWithDetails | null;
-    setStatus(goalId: string, status: GoalStatus, opts?: {
-        reason?: string;
-    }): GoalWithDetails | null;
-    pause(goalId: string, reason?: string): GoalWithDetails | null;
-    resume(goalId: string): GoalWithDetails | null;
-    reopen(goalId: string): GoalWithDetails | null;
-    complete(goalId: string): GoalWithDetails | null;
-    archive(goalId: string): GoalWithDetails | null;
-    unarchive(goalId: string): GoalWithDetails | null;
-    attachSession(goalId: string, sessionKey: string): GoalWithDetails | null;
-    updateChecklist(goalId: string, op: {
-        type: 'add';
-        text: string;
-        addedBy?: GoalChecklistAddedBy;
-    } | {
-        type: 'mark';
-        itemId: string;
-        status: GoalChecklistStatus;
-        evidenceSummary?: string;
-    } | {
-        type: 'remove';
-        itemId: string;
-    } | {
-        type: 'reset';
-    }): GoalWithDetails | null;
-    recordJudgeDecision(input: {
-        goalId: string;
-        sessionKey: string;
-        source: GoalSource;
-        decision: GoalJudgeDecision;
-    }): GoalWithDetails | null;
-    syncPostTurnState(input: {
-        goalId: string;
-        sessionKey: string;
-        source: GoalSource;
-        status: GoalStatus;
-        turnsUsed: number;
-        maxTurns: number;
-        reason?: string;
-        nextAction?: string;
-        assistantPreview?: string;
-        verdict: 'continue' | 'done' | 'blocked' | 'needs_input' | 'decompose';
-        confidence?: number;
-        missingEvidence?: string[];
-        userQuestion?: string;
-        completedChecklistItemIds?: string[];
-        checklist?: Array<{
-            text: string;
-            status: 'pending' | 'completed' | 'impossible';
-            addedBy: 'user' | 'judge';
-            addedAt?: number;
-            completedAt?: number;
-            evidenceSummary?: string;
-        }>;
-    }): GoalWithDetails | null;
-    listRuns(goalId: string, limit?: number): import("./types.js").GoalRun[];
-    listRunsForSession(sessionKey: string, limit?: number): import("./types.js").GoalRun[];
-    listEvents(goalId: string, limit?: number): import("./types.js").GoalEvent[];
-    addEvidence(input: Parameters<GoalStore['addEvidence']>[0]): import("./types.js").GoalEvidence;
-    listEvidence(goalId: string, limit?: number): import("./types.js").GoalEvidence[];
-    getCompletionReadiness(goalId: string): GoalCompletionReadiness | null;
-}
-export declare function normalizeGoalUiLocale(raw: unknown): GoalUiLocale | undefined;

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

@@ -1,323 +0,0 @@
-import { defaultMaxTurns } from "../agent/goals/state.js";
-import { publishAutomationProductEvent } from "../automations/product-events.js";
-import { GoalStore } from "./goal-store.js";
-//#region src/goals/goal-service.ts
-function normalizeTitle(title) {
-	const t = title.trim();
-	if (!t) throw new Error("Goal title is required");
-	return t;
-}
-function toTerminalStatus(verdict) {
-	if (verdict === "done") return "done";
-	if (verdict === "blocked") return "blocked";
-	if (verdict === "needs_input") return "needs_input";
-	return "active";
-}
-function completionReviewReason(readiness) {
-	const pending = readiness.pendingCriteria;
-	return pending.length ? `Completion review required: ${pending.join("; ")}` : "Completion review required.";
-}
-function publishGoalEvent(type, goal, extra) {
-	publishAutomationProductEvent({
-		type,
-		source: "goals",
-		payload: {
-			goalId: goal.id,
-			title: goal.title,
-			status: goal.status,
-			priority: goal.priority,
-			sessionKey: goal.activeSessionKey,
-			agentId: goal.agentId,
-			source: goal.source,
-			...extra
-		}
-	});
-}
-function publishGoalStatusEvent(goal, previousStatus, reason) {
-	if (previousStatus === goal.status) return;
-	publishGoalEvent("goal.status_changed", goal, {
-		previousStatus,
-		reason
-	});
-}
-var GoalService = class {
-	store;
-	constructor(store = new GoalStore()) {
-		this.store = store;
-	}
-	create(input) {
-		const sessionKey = input.sessionKey;
-		const cfg = input.config?.goals;
-		const goal = this.store.create({
-			outcomeId: input.outcomeId,
-			outcomeContractVersion: input.outcomeContractVersion,
-			title: normalizeTitle(input.title),
-			description: input.description,
-			agentId: input.agentId ?? "main",
-			sessionKey,
-			priority: input.priority,
-			deadlineAt: input.deadlineAt,
-			judgeModelRef: input.judgeModelRef ?? cfg?.judgeModelRef,
-			maxTurns: input.maxTurns ?? defaultMaxTurns(cfg),
-			uiLocale: input.uiLocale,
-			source: input.source,
-			projectId: input.projectId
-		});
-		publishGoalEvent("goal.created", goal);
-		return goal;
-	}
-	get(goalId) {
-		const goal = this.store.get(goalId);
-		if (!goal) return null;
-		return {
-			...goal,
-			checklist: this.store.listChecklist(goalId),
-			latestRun: this.store.listRuns(goalId, 1)[0],
-			contextMessage: this.store.getContextMessage(goalId) ?? void 0
-		};
-	}
-	getActiveForSession(sessionKey) {
-		const goal = this.store.getActiveForSession(sessionKey);
-		return goal ? this.get(goal.id) : null;
-	}
-	list(query = {}) {
-		return this.store.list(query).map((goal) => ({
-			...goal,
-			checklist: this.store.listChecklist(goal.id),
-			latestRun: this.store.listRuns(goal.id, 1)[0],
-			contextMessage: this.store.getContextMessage(goal.id) ?? void 0
-		}));
-	}
-	setContextMessage(input) {
-		if (!this.store.get(input.goalId)) return null;
-		this.store.setContextMessage(input);
-		return this.get(input.goalId);
-	}
-	update(goalId, patch) {
-		const normalized = { ...patch };
-		if (typeof normalized.title === "string") normalized.title = normalizeTitle(normalized.title);
-		if (typeof normalized.description === "string") normalized.description = normalized.description.trim() || void 0;
-		if (typeof normalized.judgeModelRef === "string") normalized.judgeModelRef = normalized.judgeModelRef.trim() || void 0;
-		if (typeof normalized.nextAction === "string") normalized.nextAction = normalized.nextAction.trim() || void 0;
-		if (typeof normalized.blockedReason === "string") normalized.blockedReason = normalized.blockedReason.trim() || void 0;
-		if (typeof normalized.maxTurns === "number") normalized.maxTurns = Math.max(1, Math.min(500, Math.floor(normalized.maxTurns)));
-		const goal = this.store.update(goalId, normalized);
-		return goal ? this.get(goal.id) : null;
-	}
-	setStatus(goalId, status, opts) {
-		const previous = this.store.get(goalId);
-		const now = Date.now();
-		const goal = this.store.update(goalId, {
-			status,
-			completedAt: status === "done" ? now : void 0,
-			archivedAt: status === "archived" ? now : void 0,
-			blockedReason: status === "blocked" || status === "needs_input" ? opts?.reason : void 0
-		});
-		if (goal) publishGoalStatusEvent(goal, previous?.status, opts?.reason);
-		return goal ? this.get(goal.id) : null;
-	}
-	pause(goalId, reason = "user-paused") {
-		const previous = this.store.get(goalId);
-		const goal = this.store.update(goalId, {
-			status: "paused",
-			blockedReason: reason,
-			completedAt: void 0,
-			archivedAt: void 0
-		});
-		if (goal) publishGoalStatusEvent(goal, previous?.status, reason);
-		return goal ? this.get(goal.id) : null;
-	}
-	resume(goalId) {
-		const previous = this.store.get(goalId);
-		const goal = this.store.update(goalId, {
-			status: "active",
-			blockedReason: void 0,
-			completedAt: void 0,
-			archivedAt: void 0,
-			turnsUsed: 0
-		});
-		if (goal) publishGoalStatusEvent(goal, previous?.status);
-		return goal ? this.get(goal.id) : null;
-	}
-	reopen(goalId) {
-		const previous = this.store.get(goalId);
-		const goal = this.store.update(goalId, {
-			status: "active",
-			blockedReason: void 0,
-			completedAt: void 0,
-			archivedAt: void 0,
-			turnsUsed: 0
-		});
-		if (goal) publishGoalStatusEvent(goal, previous?.status);
-		return goal ? this.get(goal.id) : null;
-	}
-	complete(goalId) {
-		return this.setStatus(goalId, "done");
-	}
-	archive(goalId) {
-		return this.setStatus(goalId, "archived");
-	}
-	unarchive(goalId) {
-		const previous = this.store.get(goalId);
-		const goal = this.store.update(goalId, {
-			status: "paused",
-			archivedAt: void 0,
-			completedAt: void 0,
-			blockedReason: void 0
-		});
-		if (goal) publishGoalStatusEvent(goal, previous?.status);
-		return goal ? this.get(goal.id) : null;
-	}
-	attachSession(goalId, sessionKey) {
-		const goal = this.store.update(goalId, { activeSessionKey: sessionKey });
-		return goal ? this.get(goal.id) : null;
-	}
-	updateChecklist(goalId, op) {
-		if (op.type === "add") {
-			const text = op.text.trim();
-			if (!text) throw new Error("Checklist item text is required");
-			this.store.addChecklistItem({
-				goalId,
-				text,
-				addedBy: op.addedBy ?? "user"
-			});
-		} else if (op.type === "mark") this.store.updateChecklistItem(op.itemId, {
-			status: op.status,
-			evidenceSummary: op.evidenceSummary
-		});
-		else if (op.type === "remove") this.store.removeChecklistItem(op.itemId);
-		else this.store.clearChecklist(goalId);
-		return this.get(goalId);
-	}
-	recordJudgeDecision(input) {
-		const goal = this.store.get(input.goalId);
-		if (!goal) return null;
-		const previousStatus = goal.status;
-		const nextStatus = toTerminalStatus(input.decision.verdict);
-		const turnsUsed = goal.turnsUsed + 1;
-		const budgetStatus = turnsUsed >= goal.maxTurns && nextStatus === "active" ? "paused" : nextStatus;
-		const readiness = budgetStatus === "done" ? this.getCompletionReadiness(input.goalId) : null;
-		const status = readiness && !readiness.ready ? "needs_input" : budgetStatus;
-		const reason = readiness && !readiness.ready ? completionReviewReason(readiness) : status === "paused" && turnsUsed >= goal.maxTurns ? `turn budget exhausted (${turnsUsed}/${goal.maxTurns})` : input.decision.reason;
-		const run = this.store.appendRun({
-			goalId: input.goalId,
-			sessionKey: input.sessionKey,
-			source: input.source,
-			status: "succeeded",
-			finishedAt: Date.now(),
-			verdict: input.decision.verdict,
-			reason: input.decision.reason,
-			nextAction: input.decision.nextAction,
-			assistantPreview: input.decision.assistantPreview,
-			checklistProgress: input.decision.checklistProgress,
-			confidence: input.decision.confidence,
-			missingEvidence: input.decision.missingEvidence,
-			userQuestion: input.decision.userQuestion,
-			completedChecklistItemIds: input.decision.completedChecklistItemIds
-		});
-		const updated = this.store.update(input.goalId, {
-			status,
-			turnsUsed,
-			currentRunId: run.id,
-			nextAction: input.decision.nextAction,
-			blockedReason: status === "blocked" || status === "needs_input" || status === "paused" ? reason : void 0,
-			completedAt: status === "done" ? Date.now() : void 0
-		});
-		if (updated) publishGoalStatusEvent(updated, previousStatus, reason);
-		return this.get(input.goalId);
-	}
-	syncPostTurnState(input) {
-		const goal = this.store.get(input.goalId);
-		if (!goal) return null;
-		const previousStatus = goal.status;
-		if (input.checklist) this.store.replaceChecklist(input.goalId, input.checklist);
-		const total = input.checklist?.length ?? this.store.listChecklist(input.goalId).length;
-		const done = (input.checklist ?? this.store.listChecklist(input.goalId)).filter((it) => it.status === "completed" || it.status === "impossible").length;
-		const run = this.store.appendRun({
-			goalId: input.goalId,
-			sessionKey: input.sessionKey,
-			source: input.source,
-			status: "succeeded",
-			finishedAt: Date.now(),
-			verdict: input.verdict,
-			reason: input.reason,
-			nextAction: input.nextAction,
-			assistantPreview: input.assistantPreview,
-			checklistProgress: total > 0 ? {
-				done,
-				total
-			} : void 0,
-			confidence: input.confidence,
-			missingEvidence: input.missingEvidence,
-			userQuestion: input.userQuestion,
-			completedChecklistItemIds: input.completedChecklistItemIds
-		});
-		for (const item of input.checklist ?? []) if ((item.status === "completed" || item.status === "impossible") && item.evidenceSummary?.trim()) this.store.addEvidence({
-			goalId: input.goalId,
-			runId: run.id,
-			kind: "message",
-			title: `Checklist evidence: ${item.text.slice(0, 80)}`,
-			summary: item.evidenceSummary.trim()
-		});
-		for (const missing of input.missingEvidence ?? []) {
-			if (!missing.trim()) continue;
-			this.store.addEvidence({
-				goalId: input.goalId,
-				runId: run.id,
-				kind: "message",
-				title: `Missing evidence: ${missing.slice(0, 80)}`,
-				summary: missing
-			});
-		}
-		if (input.userQuestion?.trim()) this.store.addEvidence({
-			goalId: input.goalId,
-			runId: run.id,
-			kind: "message",
-			title: "User input requested",
-			summary: input.userQuestion.trim()
-		});
-		const readiness = input.status === "done" ? this.getCompletionReadiness(input.goalId) : null;
-		const status = readiness && !readiness.ready ? "needs_input" : input.status;
-		const completionReason = readiness && !readiness.ready ? completionReviewReason(readiness) : input.reason;
-		const updated = this.store.update(input.goalId, {
-			status,
-			turnsUsed: input.turnsUsed,
-			maxTurns: input.maxTurns,
-			currentRunId: run.id,
-			nextAction: input.nextAction,
-			blockedReason: status === "blocked" || status === "needs_input" || status === "paused" ? completionReason : void 0,
-			completedAt: status === "done" ? Date.now() : void 0
-		});
-		if (updated) publishGoalStatusEvent(updated, previousStatus, completionReason);
-		return this.get(input.goalId);
-	}
-	listRuns(goalId, limit) {
-		return this.store.listRuns(goalId, limit);
-	}
-	listRunsForSession(sessionKey, limit) {
-		return this.store.listRunsForSession(sessionKey, limit);
-	}
-	listEvents(goalId, limit) {
-		return this.store.listEvents(goalId, limit);
-	}
-	addEvidence(input) {
-		return this.store.addEvidence(input);
-	}
-	listEvidence(goalId, limit) {
-		return this.store.listEvidence(goalId, limit);
-	}
-	getCompletionReadiness(goalId) {
-		const goal = this.get(goalId);
-		if (!goal) return null;
-		const pendingCriteria = goal.checklist.filter((item) => item.status === "pending").map((item) => item.text);
-		return {
-			ready: pendingCriteria.length === 0,
-			pendingCriteria
-		};
-	}
-};
-function normalizeGoalUiLocale(raw) {
-	return raw === "en" || raw === "zh" ? raw : void 0;
-}
-//#endregion
-export { GoalService, normalizeGoalUiLocale };

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

@@ -1,44 +0,0 @@
-import type { CreateGoalInput, Goal, GoalChecklistAddedBy, GoalChecklistItem, GoalChecklistStatus, GoalContextAttachment, GoalContextMessage, GoalEvent, GoalEvidence, GoalListQuery, GoalRun } from './types.js';
-export declare class GoalStore {
-    create(input: CreateGoalInput): Goal;
-    get(goalId: string): Goal | null;
-    setContextMessage(input: {
-        goalId: string;
-        text: string;
-        attachments?: GoalContextAttachment[];
-    }): GoalContextMessage;
-    getContextMessage(goalId: string): GoalContextMessage | null;
-    getActiveForSession(sessionKey: string): Goal | null;
-    list(query?: GoalListQuery): Goal[];
-    update(goalId: string, patch: Partial<Pick<Goal, 'title' | 'description' | 'status' | 'priority' | 'deadlineAt' | 'completedAt' | 'archivedAt' | 'activeSessionKey' | 'currentRunId' | 'nextAction' | 'blockedReason' | 'judgeModelRef' | 'maxTurns' | 'turnsUsed' | 'uiLocale' | 'projectId'>>): Goal | null;
-    listChecklist(goalId: string): GoalChecklistItem[];
-    addChecklistItem(input: {
-        goalId: string;
-        text: string;
-        addedBy: GoalChecklistAddedBy;
-        status?: GoalChecklistStatus;
-    }): GoalChecklistItem;
-    updateChecklistItem(itemId: string, patch: Partial<Pick<GoalChecklistItem, 'text' | 'status' | 'evidenceSummary'>>): GoalChecklistItem | null;
-    removeChecklistItem(itemId: string): boolean;
-    clearChecklist(goalId: string): void;
-    replaceChecklist(goalId: string, items: Array<{
-        text: string;
-        status: GoalChecklistStatus;
-        addedBy: GoalChecklistAddedBy;
-        addedAt?: number;
-        completedAt?: number;
-        evidenceSummary?: string;
-    }>): GoalChecklistItem[];
-    appendRun(run: Omit<GoalRun, 'id' | 'startedAt'> & {
-        id?: string;
-        startedAt?: number;
-    }): GoalRun;
-    listRuns(goalId: string, limit?: number): GoalRun[];
-    listRunsForSession(sessionKey: string, limit?: number): GoalRun[];
-    listEvents(goalId: string, limit?: number): GoalEvent[];
-    addEvidence(input: Omit<GoalEvidence, 'id' | 'createdAt'> & {
-        id?: string;
-        createdAt?: number;
-    }): GoalEvidence;
-    listEvidence(goalId: string, limit?: number): GoalEvidence[];
-}