@xopcai/xopc 0.0.180 → 0.0.188

package/dist/src/tasks/task-context-repository.js

@@ -0,0 +1,97 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/tasks/task-context-repository.ts
+function edgeFromRow(row) {
+	return {
+		id: row.edge_id,
+		taskId: row.owner_id,
+		targetKind: row.target_kind,
+		targetId: row.target_id,
+		role: row.role,
+		...row.title ? { title: row.title } : {},
+		pinned: row.pinned === 1,
+		retrievalPolicy: JSON.parse(row.retrieval_policy_json),
+		metadata: JSON.parse(row.metadata_json),
+		createdBy: JSON.parse(row.created_by_json),
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function grantFromRow(row) {
+	return {
+		id: row.grant_id,
+		taskId: row.task_id,
+		capability: row.capability,
+		scope: JSON.parse(row.scope_json),
+		grantedBy: JSON.parse(row.granted_by_json),
+		grantedAt: row.granted_at,
+		...row.expires_at === null ? {} : { expiresAt: row.expires_at },
+		...row.revoked_at === null ? {} : { revokedAt: row.revoked_at }
+	};
+}
+var TaskContextRepository = class {
+	captureSnapshot(input) {
+		const id = randomUUID();
+		const traceId = randomUUID();
+		getSqliteDatabase().prepare(`INSERT INTO context_snapshots (
+        snapshot_id, trace_id, owner_kind, owner_id, session_key, query,
+        selected_items_json, rejected_items_json, consent_requests_json,
+        relationship_policy_json, estimated_tokens, allocation_json,
+        authorization_snapshot_json, content_hash, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, traceId, input.ownerKind, input.ownerId, input.sessionKey ?? null, input.query, JSON.stringify(input.selectedItems ?? []), JSON.stringify(input.rejectedItems ?? []), JSON.stringify(input.consentRequests ?? []), JSON.stringify(input.relationshipPolicy ?? {}), input.estimatedTokens ?? 0, input.allocation ? JSON.stringify(input.allocation) : null, JSON.stringify(input.authorizationSnapshot ?? {}), input.contentHash ?? null, input.now ?? Date.now());
+		return {
+			id,
+			traceId
+		};
+	}
+	add(input) {
+		const now = input.now ?? Date.now();
+		const id = randomUUID();
+		getSqliteDatabase().prepare(`INSERT INTO context_edges (
+        edge_id, owner_kind, owner_id, target_kind, target_id, role, title,
+        pinned, retrieval_policy_json, metadata_json, created_by_json,
+        created_at, updated_at
+      ) VALUES (?, 'task', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(owner_kind, owner_id, target_kind, target_id, role)
+      DO UPDATE SET title = excluded.title, pinned = excluded.pinned,
+        retrieval_policy_json = excluded.retrieval_policy_json,
+        metadata_json = excluded.metadata_json, updated_at = excluded.updated_at`).run(id, input.taskId, input.targetKind, input.targetId, input.role, input.title?.trim() || null, input.pinned ? 1 : 0, JSON.stringify(input.retrievalPolicy ?? {}), JSON.stringify(input.metadata ?? {}), JSON.stringify(input.createdBy), now, now);
+		return edgeFromRow(getSqliteDatabase().prepare(`SELECT * FROM context_edges WHERE owner_kind = 'task' AND owner_id = ?
+       AND target_kind = ? AND target_id = ? AND role = ?`).get(input.taskId, input.targetKind, input.targetId, input.role));
+	}
+	list(taskId) {
+		return getSqliteDatabase().prepare(`SELECT * FROM context_edges WHERE owner_kind = 'task' AND owner_id = ?
+       ORDER BY pinned DESC, created_at ASC`).all(taskId).map(edgeFromRow);
+	}
+	remove(taskId, edgeId) {
+		return getSqliteDatabase().prepare(`DELETE FROM context_edges WHERE edge_id = ? AND owner_kind = 'task' AND owner_id = ?`).run(edgeId, taskId).changes > 0;
+	}
+	grant(input) {
+		const id = randomUUID();
+		const now = input.now ?? Date.now();
+		getSqliteDatabase().prepare(`INSERT INTO task_authority_grants (
+        grant_id, task_id, capability, scope_json, granted_by_json,
+        granted_at, expires_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, input.taskId, input.capability, JSON.stringify(input.scope ?? {}), JSON.stringify(input.grantedBy), now, input.expiresAt ?? null);
+		return this.requireGrant(id);
+	}
+	listActiveGrants(taskId, now = Date.now()) {
+		return getSqliteDatabase().prepare(`SELECT * FROM task_authority_grants WHERE task_id = ? AND revoked_at IS NULL
+       AND (expires_at IS NULL OR expires_at > ?) ORDER BY granted_at ASC`).all(taskId, now).map(grantFromRow);
+	}
+	revoke(grantId, now = Date.now()) {
+		return getSqliteDatabase().prepare(`UPDATE task_authority_grants SET revoked_at = ?
+       WHERE grant_id = ? AND revoked_at IS NULL`).run(now, grantId).changes > 0;
+	}
+	linkSession(input) {
+		getSqliteDatabase().prepare(`INSERT OR IGNORE INTO task_sessions (task_session_id, task_id, session_key, role, created_at)
+       VALUES (?, ?, ?, ?, ?)`).run(randomUUID(), input.taskId, input.sessionKey, input.role, input.now ?? Date.now());
+	}
+	requireGrant(id) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM task_authority_grants WHERE grant_id = ?").get(id);
+		if (!row) throw new Error(`Task authority grant not found: ${id}`);
+		return grantFromRow(row);
+	}
+};
+//#endregion
+export { TaskContextRepository };

package/dist/src/tasks/task-contract-definition.d.ts

@@ -0,0 +1,10 @@
+export interface TaskContractDefinition {
+    objective: string;
+    expectedOutputs: string[];
+    acceptanceCriteria: string[];
+    constraints: string[];
+    approvalRequired: string[];
+    assumptions: string[];
+    risks: string[];
+}
+export declare function defineTaskContract(objectiveInput: string): TaskContractDefinition;

package/dist/src/{work/outcome-contract-definition.js → tasks/task-contract-definition.js}

@@ -1,15 +1,17 @@
-//#region src/work/outcome-contract-definition.ts
-function defineOutcomeContract(objectiveInput) {
+//#region src/tasks/task-contract-definition.ts
+function defineTaskContract(objectiveInput) {
 	const objective = objectiveInput.trim();
 	if (!objective) throw new Error("Objective is required");
 	const chinese = /[\u3400-\u9fff]/u.test(objective);
 	return {
 		objective,
-		deliverables: [objective],
+		expectedOutputs: [objective],
 		acceptanceCriteria: chinese ? [`已交付：${objective}`, "结果有可检查的证据，并满足用户明确提出的约束。"] : [`Delivered: ${objective}`, "The result has inspectable evidence and satisfies the user-provided constraints."],
 		constraints: [],
-		approvalRequired: []
+		approvalRequired: [],
+		assumptions: [],
+		risks: []
 	};
 }
 //#endregion
-export { defineOutcomeContract };
+export { defineTaskContract };

package/dist/src/tasks/task-contract-planner.d.ts

@@ -0,0 +1,17 @@
+import { type Config } from '../config/schema.js';
+import { type TaskContractDefinition } from './task-contract-definition.js';
+export interface TaskContractPlanningInput {
+    objective: string;
+    taskContext?: string;
+    projectContext?: string;
+    userContext?: string;
+}
+export interface TaskContractPlanner {
+    plan(input: TaskContractPlanningInput): Promise<TaskContractDefinition>;
+}
+export declare function parseTaskContractResponse(raw: string): TaskContractDefinition | undefined;
+export declare class ModelTaskContractPlanner implements TaskContractPlanner {
+    private readonly getConfig;
+    constructor(getConfig: () => Config);
+    plan(input: TaskContractPlanningInput): Promise<TaskContractDefinition>;
+}

package/dist/src/tasks/task-contract-planner.js

@@ -0,0 +1,87 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
+import { init_providers, resolveModel } from "../providers/index.js";
+import { completeWithResolvedCredentials, resolveModelCallApiKey } from "../providers/model-call.js";
+import { defineTaskContract } from "./task-contract-definition.js";
+//#region src/tasks/task-contract-planner.ts
+init_schema();
+init_providers();
+init_logger();
+const log = createLogger("TaskContractPlanner");
+function extractText(content) {
+	if (!Array.isArray(content)) return "";
+	return content.filter((item) => Boolean(item && typeof item === "object" && item.type === "text" && typeof item.text === "string")).map((item) => item.text).join("\n").trim();
+}
+function parseObject(raw) {
+	const start = raw.indexOf("{");
+	const end = raw.lastIndexOf("}");
+	if (start < 0 || end <= start) return void 0;
+	try {
+		const parsed = JSON.parse(raw.slice(start, end + 1));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function strings(value, max) {
+	if (!Array.isArray(value)) return [];
+	return [...new Set(value.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean))].slice(0, max);
+}
+function parseTaskContractResponse(raw) {
+	const parsed = parseObject(raw);
+	if (!parsed) return void 0;
+	const objective = typeof parsed.objective === "string" ? parsed.objective.trim() : "";
+	const expectedOutputs = strings(parsed.expectedOutputs, 8);
+	const acceptanceCriteria = strings(parsed.acceptanceCriteria, 12);
+	if (!objective || expectedOutputs.length === 0 || acceptanceCriteria.length === 0) return void 0;
+	return {
+		objective,
+		expectedOutputs,
+		acceptanceCriteria,
+		constraints: strings(parsed.constraints, 10),
+		approvalRequired: strings(parsed.approvalRequired, 8),
+		assumptions: strings(parsed.assumptions, 10),
+		risks: strings(parsed.risks, 10)
+	};
+}
+var ModelTaskContractPlanner = class {
+	constructor(getConfig) {
+		this.getConfig = getConfig;
+	}
+	async plan(input) {
+		const fallback = defineTaskContract(input.objective);
+		try {
+			const model = resolveModel(getAgentDefaultModelRef(this.getConfig()));
+			const planned = parseTaskContractResponse(extractText((await completeWithResolvedCredentials(model, { messages: [{
+				role: "user",
+				content: [
+					"Define the smallest complete, verifiable contract for the user task.",
+					"Preserve the user intent. Do not invent requirements or ask for optional preferences.",
+					"Acceptance criteria must describe externally checkable finished states, not activities.",
+					"List assumptions explicitly. Put only irreversible, external, financial, privacy, or permission decisions in approvalRequired.",
+					"Return one JSON object only with keys: objective, expectedOutputs, acceptanceCriteria, constraints, approvalRequired, assumptions, risks.",
+					"",
+					`User request:\n${input.objective.trim()}`,
+					input.taskContext ? `\nUser-provided task context:\n${input.taskContext.slice(0, 16e3)}` : "",
+					input.projectContext ? `\nProject context:\n${input.projectContext.slice(0, 8e3)}` : "",
+					input.userContext ? `\nUser context:\n${input.userContext.slice(0, 8e3)}` : ""
+				].join("\n"),
+				timestamp: Date.now()
+			}] }, {
+				apiKey: await resolveModelCallApiKey(model),
+				maxTokens: 2e3,
+				temperature: 0
+			})).content));
+			return planned ? {
+				...planned,
+				objective: fallback.objective
+			} : fallback;
+		} catch (err) {
+			log.warn({ err }, "Task contract planning fell back to deterministic criteria");
+			return fallback;
+		}
+	}
+};
+//#endregion
+export { ModelTaskContractPlanner, parseTaskContractResponse };

package/dist/src/tasks/task-dependency-service.d.ts

@@ -0,0 +1,21 @@
+import type { TaskDependencySummary } from '@xopcai/gateway-contract';
+import { type TaskAggregate } from './task-repository.js';
+export type TaskDependencyErrorCode = 'not_found' | 'conflict' | 'invalid_dependency' | 'cycle';
+export declare class TaskDependencyError extends Error {
+    readonly code: TaskDependencyErrorCode;
+    constructor(code: TaskDependencyErrorCode, message: string);
+}
+export declare class TaskDependencyService {
+    #private;
+    listDependencies(taskId: string): TaskDependencySummary[];
+    listDependents(taskId: string): TaskDependencySummary[];
+    listBlocking(taskId: string): TaskDependencySummary[];
+    listReadyDependents(taskId: string): TaskAggregate[];
+    replace(input: {
+        taskId: string;
+        dependsOnTaskIds: string[];
+        expectedVersion: number;
+        now?: number;
+    }): TaskAggregate;
+    private listRelated;
+}

package/dist/src/tasks/task-dependency-service.js

@@ -0,0 +1,81 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { TaskRepository } from "./task-repository.js";
+import { TaskReadModelProjector } from "./task-read-model-projector.js";
+//#region src/tasks/task-dependency-service.ts
+var TaskDependencyError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "TaskDependencyError";
+	}
+};
+var TaskDependencyService = class {
+	#tasks = new TaskRepository();
+	#projector = new TaskReadModelProjector();
+	listDependencies(taskId) {
+		return this.listRelated(`SELECT depends_on_task_id AS task_id FROM task_dependencies
+       WHERE task_id = ? ORDER BY created_at ASC, depends_on_task_id ASC`, taskId);
+	}
+	listDependents(taskId) {
+		return this.listRelated(`SELECT task_id FROM task_dependencies
+       WHERE depends_on_task_id = ? ORDER BY created_at ASC, task_id ASC`, taskId);
+	}
+	listBlocking(taskId) {
+		return this.listDependencies(taskId).filter((dependency) => dependency.phase !== "closed" || dependency.resolution !== "done");
+	}
+	listReadyDependents(taskId) {
+		return getSqliteDatabase().prepare(`SELECT dependent.task_id
+       FROM task_dependencies completed_edge
+       JOIN tasks dependent ON dependent.task_id = completed_edge.task_id
+       WHERE completed_edge.depends_on_task_id = ?
+         AND dependent.phase <> 'closed'
+         AND NOT EXISTS (
+           SELECT 1 FROM task_dependencies edge
+           JOIN tasks dependency ON dependency.task_id = edge.depends_on_task_id
+           WHERE edge.task_id = dependent.task_id
+             AND NOT (dependency.phase = 'closed' AND dependency.resolution = 'done')
+         )
+       ORDER BY dependent.created_at ASC`).all(taskId).flatMap((row) => {
+			const task = this.#tasks.get(row.task_id);
+			return task ? [task] : [];
+		});
+	}
+	replace(input) {
+		const dependencyIds = [...new Set(input.dependsOnTaskIds.map((id) => id.trim()).filter(Boolean))];
+		if (dependencyIds.includes(input.taskId)) throw new TaskDependencyError("invalid_dependency", "A task cannot depend on itself");
+		runSqliteWriteTransaction((db) => {
+			const task = db.prepare("SELECT version, updated_at FROM tasks WHERE task_id = ?").get(input.taskId);
+			if (!task) throw new TaskDependencyError("not_found", "Task not found");
+			if (task.version !== input.expectedVersion) throw new TaskDependencyError("conflict", "Task changed before its dependencies were saved");
+			for (const dependencyId of dependencyIds) if (!db.prepare("SELECT 1 FROM tasks WHERE task_id = ?").get(dependencyId)) throw new TaskDependencyError("invalid_dependency", `Dependency task not found: ${dependencyId}`);
+			db.prepare("DELETE FROM task_dependencies WHERE task_id = ?").run(input.taskId);
+			const createsCycle = db.prepare(`WITH RECURSIVE dependencies(task_id) AS (
+           SELECT ?
+           UNION
+           SELECT edge.depends_on_task_id
+           FROM task_dependencies edge
+           JOIN dependencies current ON current.task_id = edge.task_id
+         )
+         SELECT 1 FROM dependencies WHERE task_id = ? LIMIT 1`);
+			const insert = db.prepare(`INSERT INTO task_dependencies (
+          task_id, depends_on_task_id, dependency_kind, created_at
+        ) VALUES (?, ?, 'blocks', ?)`);
+			const now = Math.max(input.now ?? Date.now(), task.updated_at + 1);
+			for (const dependencyId of dependencyIds) {
+				if (createsCycle.get(dependencyId, input.taskId)) throw new TaskDependencyError("cycle", "Task dependencies must form an acyclic graph");
+				insert.run(input.taskId, dependencyId, now);
+			}
+			db.prepare(`UPDATE tasks SET version = version + 1, updated_at = ?
+         WHERE task_id = ? AND version = ?`).run(now, input.taskId, input.expectedVersion);
+		});
+		return this.#tasks.require(input.taskId);
+	}
+	listRelated(sql, taskId) {
+		return getSqliteDatabase().prepare(sql).all(taskId).flatMap((row) => {
+			const summary = this.#projector.summary(row.task_id);
+			return summary ? [summary] : [];
+		});
+	}
+};
+//#endregion
+export { TaskDependencyError, TaskDependencyService };

package/dist/src/tasks/task-outbox-dispatcher.d.ts

@@ -0,0 +1,6 @@
+import type { AutomationEvent } from '../automations/domain/types.js';
+export declare class TaskOutboxDispatcher {
+    private readonly publish;
+    constructor(publish: (event: AutomationEvent) => void);
+    drain(limit?: number): number;
+}

package/dist/src/tasks/task-outbox-dispatcher.js

@@ -0,0 +1,31 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+//#region src/tasks/task-outbox-dispatcher.ts
+var TaskOutboxDispatcher = class {
+	constructor(publish) {
+		this.publish = publish;
+	}
+	drain(limit = 100) {
+		const rows = getSqliteDatabase().prepare(`SELECT event_id, event_type, payload_json, created_at
+       FROM domain_outbox WHERE published_at IS NULL
+       ORDER BY created_at, event_id LIMIT ?`).all(Math.max(1, Math.min(500, Math.floor(limit))));
+		let published = 0;
+		for (const row of rows) try {
+			this.publish({
+				type: row.event_type,
+				source: "tasks",
+				payload: JSON.parse(row.payload_json),
+				occurredAtMs: row.created_at
+			});
+			runSqliteWriteTransaction((db) => {
+				db.prepare(`UPDATE domain_outbox SET published_at = ?, attempts = attempts + 1
+             WHERE event_id = ? AND published_at IS NULL`).run(Date.now(), row.event_id);
+			});
+			published += 1;
+		} catch {
+			getSqliteDatabase().prepare("UPDATE domain_outbox SET attempts = attempts + 1 WHERE event_id = ?").run(row.event_id);
+		}
+		return published;
+	}
+};
+//#endregion
+export { TaskOutboxDispatcher };

package/dist/src/tasks/task-read-model-projector.d.ts

@@ -0,0 +1,16 @@
+import type { TaskAttentionItem, TaskDependencySummary, TaskOperationalState } from '@xopcai/gateway-contract';
+import { type TaskAggregate } from './task-repository.js';
+export interface TaskReadModel {
+    task: TaskAggregate;
+    operationalState: TaskOperationalState;
+    attention: TaskAttentionItem[];
+    allowedCommands: string[];
+}
+export declare class TaskReadModelProjector {
+    #private;
+    get(taskId: string): TaskReadModel | undefined;
+    project(task: TaskAggregate, now?: number): TaskReadModel;
+    summary(taskId: string): TaskDependencySummary | undefined;
+    private operationalState;
+    private allowedCommands;
+}

package/dist/src/tasks/task-read-model-projector.js

@@ -0,0 +1,93 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import { TaskRepository } from "./task-repository.js";
+import { TaskRunRepository } from "./task-run-repository.js";
+//#region src/tasks/task-read-model-projector.ts
+var TaskReadModelProjector = class {
+	#tasks = new TaskRepository();
+	#runs = new TaskRunRepository();
+	get(taskId) {
+		const task = this.#tasks.get(taskId);
+		return task ? this.project(task) : void 0;
+	}
+	project(task, now = Date.now()) {
+		const activeRun = this.#runs.getActiveRoot(task.id);
+		const latestRun = activeRun ?? this.#runs.getLatestRoot(task.id);
+		const waits = this.#runs.listActiveWaits(task.id);
+		const hasIncompleteDependency = Boolean(getSqliteDatabase().prepare(`SELECT 1 FROM task_dependencies edge
+       JOIN tasks dependency ON dependency.task_id = edge.depends_on_task_id
+       WHERE edge.task_id = ?
+         AND NOT (dependency.phase = 'closed' AND dependency.resolution = 'done')
+       LIMIT 1`).get(task.id));
+		const attention = [];
+		for (const wait of waits) {
+			const kind = wait.kind === "approval" ? "approval_required" : wait.kind === "user_input" ? "input_required" : wait.kind === "dependency" ? "dependency_blocked" : void 0;
+			if (kind) attention.push({
+				kind,
+				summary: wait.reason,
+				sourceId: wait.id
+			});
+		}
+		if (latestRun?.status === "failed") {
+			const receipt = this.#runs.getReceipt(latestRun.id);
+			attention.push({
+				kind: receipt?.verification.status === "failed" ? "verification_failed" : "run_failed",
+				summary: latestRun.terminalMessage ?? receipt?.summary ?? "The latest run failed",
+				sourceId: latestRun.id
+			});
+		}
+		if (task.dueAt !== void 0 && task.phase !== "closed" && task.dueAt < now) attention.push({
+			kind: "overdue",
+			summary: "Task is overdue"
+		});
+		return {
+			task,
+			operationalState: this.operationalState({
+				task,
+				activeRun,
+				latestRun,
+				waits,
+				hasIncompleteDependency
+			}),
+			attention,
+			allowedCommands: this.allowedCommands(task, activeRun?.status, waits.length > 0)
+		};
+	}
+	summary(taskId) {
+		const model = this.get(taskId);
+		if (!model) return void 0;
+		return {
+			id: model.task.id,
+			title: model.task.title,
+			phase: model.task.phase,
+			...model.task.resolution ? { resolution: model.task.resolution } : {},
+			operationalState: model.operationalState
+		};
+	}
+	operationalState(input) {
+		if (input.task.phase === "closed") return "idle";
+		if (input.activeRun?.status === "running") return "running";
+		if (input.activeRun?.status === "verifying") return "verifying";
+		if (input.activeRun?.status === "queued") return "queued";
+		if (input.waits.some((wait) => wait.kind !== "dependency")) return "waiting";
+		if (input.waits.some((wait) => wait.kind === "dependency")) return "blocked";
+		if (input.latestRun?.status === "failed") return "blocked";
+		if (input.hasIncompleteDependency) return "blocked";
+		return "idle";
+	}
+	allowedCommands(task, activeRunStatus, hasWaits) {
+		if (task.phase === "closed") return ["reopen"];
+		const commands = [
+			"revise_contract",
+			"delegate",
+			"close"
+		];
+		if (hasWaits) commands.unshift("resolve_wait");
+		else if (activeRunStatus === "running" || activeRunStatus === "verifying") commands.unshift("add_wait");
+		if (task.phase === "backlog") commands.unshift("mark_ready");
+		if (!activeRunStatus && !hasWaits && task.phase !== "backlog") commands.unshift("start");
+		if (task.phase === "active") commands.push("request_review");
+		return commands;
+	}
+};
+//#endregion
+export { TaskReadModelProjector };

package/dist/src/tasks/task-repository.d.ts

@@ -0,0 +1,82 @@
+import type { ActorRef, Task, TaskAcceptancePolicy, TaskContract, TaskPhase, TaskPriority, TaskResolution } from '@xopcai/gateway-contract';
+export type TaskExecutionSource = 'chat' | 'cli' | 'cron' | 'workflow' | 'channel' | 'api';
+export type TaskUiLocale = 'en' | 'zh';
+export type TaskAggregate = Task;
+export interface TaskCreateInput {
+    id?: string;
+    idempotencyKey?: string;
+    title: string;
+    body?: string;
+    phase?: Extract<TaskPhase, 'backlog' | 'ready'>;
+    projectId?: string;
+    milestoneId?: string;
+    parentTaskId?: string;
+    priority?: TaskPriority;
+    dueAt?: number;
+    ownerId?: string;
+    delegateAgentId?: string;
+    source?: TaskExecutionSource;
+    locale?: TaskUiLocale;
+    objective: string;
+    expectedOutputs?: string[];
+    acceptanceCriteria?: string[];
+    constraints?: string[];
+    approvalRequired?: string[];
+    assumptions?: string[];
+    risks?: string[];
+    acceptancePolicy?: TaskAcceptancePolicy;
+    outputDestinations?: Array<Record<string, unknown>>;
+    createdBy?: ActorRef;
+    now?: number;
+}
+export declare class TaskRepository {
+    create(input: TaskCreateInput): TaskAggregate;
+    get(id: string): TaskAggregate | undefined;
+    require(id: string): TaskAggregate;
+    getByIdempotencyKey(key: string): TaskAggregate | undefined;
+    getBySession(sessionKey: string): TaskAggregate | undefined;
+    list(input?: {
+        phase?: TaskPhase;
+        projectId?: string;
+        limit?: number;
+    }): TaskAggregate[];
+    listByProject(projectId: string, limit?: number): TaskAggregate[];
+    getContract(taskId: string, version?: number): TaskContract | undefined;
+    update(taskId: string, patch: {
+        expectedVersion: number;
+        title?: string;
+        body?: string | null;
+        projectId?: string | null;
+        milestoneId?: string | null;
+        parentTaskId?: string | null;
+        priority?: TaskPriority;
+        dueAt?: number | null;
+        ownerId?: string | null;
+        delegateAgentId?: string | null;
+        now?: number;
+    }): TaskAggregate | undefined;
+    setLifecycle(input: {
+        taskId: string;
+        expectedVersion: number;
+        phase: TaskPhase;
+        resolution?: TaskResolution;
+        now?: number;
+    }): TaskAggregate | undefined;
+    reviseContract(input: {
+        taskId: string;
+        objective: string;
+        expectedOutputs: string[];
+        acceptanceCriteria: string[];
+        constraints: string[];
+        approvalRequired: string[];
+        assumptions: string[];
+        risks: string[];
+        acceptancePolicy: TaskAcceptancePolicy;
+        outputDestinations: Array<Record<string, unknown>>;
+        createdBy: ActorRef;
+        expectedVersion: number;
+        now?: number;
+    }): TaskAggregate | undefined;
+    delete(taskId: string): boolean;
+    private insertContract;
+}