@xopcai/xopc 0.0.312 → 0.0.314

package/dist/src/tasks/capabilities/relations.d.ts

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+export declare const TaskDependenciesOutputSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    task: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        body: z.ZodOptional<z.ZodString>;
+        phase: z.ZodEnum<{
+            backlog: "backlog";
+            ready: "ready";
+            active: "active";
+            review: "review";
+            closed: "closed";
+        }>;
+        resolution: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            duplicate: "duplicate";
+            wont_do: "wont_do";
+        }>>;
+        priority: z.ZodEnum<{
+            low: "low";
+            normal: "normal";
+            high: "high";
+            critical: "critical";
+        }>;
+        dueAt: z.ZodOptional<z.ZodNumber>;
+        projectId: z.ZodOptional<z.ZodString>;
+        milestoneId: z.ZodOptional<z.ZodString>;
+        parentTaskId: z.ZodOptional<z.ZodString>;
+        ownerId: z.ZodOptional<z.ZodString>;
+        delegateAgentId: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+        locale: z.ZodOptional<z.ZodEnum<{
+            en: "en";
+            zh: "zh";
+        }>>;
+        latestContractVersion: z.ZodNumber;
+        boardRank: z.ZodDefault<z.ZodNumber>;
+        version: z.ZodNumber;
+        contract: z.ZodOptional<z.ZodObject<{
+            taskId: z.ZodString;
+            version: z.ZodNumber;
+            objective: z.ZodString;
+            expectedOutputs: z.ZodArray<z.ZodString>;
+            acceptanceCriteria: z.ZodArray<z.ZodString>;
+            constraints: z.ZodArray<z.ZodString>;
+            approvalRequired: z.ZodArray<z.ZodString>;
+            assumptions: z.ZodArray<z.ZodString>;
+            risks: z.ZodArray<z.ZodString>;
+            acceptancePolicy: z.ZodEnum<{
+                verified_auto: "verified_auto";
+                verified_then_review: "verified_then_review";
+                manual: "manual";
+            }>;
+            outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            createdBy: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    user: "user";
+                    agent: "agent";
+                    system: "system";
+                    integration: "integration";
+                }>;
+                id: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            createdAt: z.ZodNumber;
+        }, z.core.$strip>>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        closedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    dependencies: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        phase: z.ZodEnum<{
+            backlog: "backlog";
+            ready: "ready";
+            active: "active";
+            review: "review";
+            closed: "closed";
+        }>;
+        resolution: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            duplicate: "duplicate";
+            wont_do: "wont_do";
+        }>>;
+        operationalState: z.ZodEnum<{
+            waiting: "waiting";
+            idle: "idle";
+            queued: "queued";
+            running: "running";
+            verifying: "verifying";
+            blocked: "blocked";
+        }>;
+    }, z.core.$strip>>;
+    dependents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        phase: z.ZodEnum<{
+            backlog: "backlog";
+            ready: "ready";
+            active: "active";
+            review: "review";
+            closed: "closed";
+        }>;
+        resolution: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            duplicate: "duplicate";
+            wont_do: "wont_do";
+        }>>;
+        operationalState: z.ZodEnum<{
+            waiting: "waiting";
+            idle: "idle";
+            queued: "queued";
+            running: "running";
+            verifying: "verifying";
+            blocked: "blocked";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TaskContextMutationOutputSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    taskId: z.ZodString;
+    edgeId: z.ZodString;
+    version: z.ZodNumber;
+    edge: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        taskId: z.ZodString;
+        targetKind: z.ZodEnum<{
+            session: "session";
+            task: "task";
+            file: "file";
+            memory: "memory";
+            document: "document";
+            url: "url";
+            source: "source";
+            artifact: "artifact";
+        }>;
+        targetId: z.ZodString;
+        role: z.ZodEnum<{
+            evidence: "evidence";
+            input: "input";
+            reference: "reference";
+            constraint: "constraint";
+            deliverable: "deliverable";
+        }>;
+        title: z.ZodOptional<z.ZodString>;
+        pinned: z.ZodBoolean;
+        retrievalPolicy: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+                integration: "integration";
+            }>;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    context: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        taskId: z.ZodString;
+        targetKind: z.ZodEnum<{
+            session: "session";
+            task: "task";
+            file: "file";
+            memory: "memory";
+            document: "document";
+            url: "url";
+            source: "source";
+            artifact: "artifact";
+        }>;
+        targetId: z.ZodString;
+        role: z.ZodEnum<{
+            evidence: "evidence";
+            input: "input";
+            reference: "reference";
+            constraint: "constraint";
+            deliverable: "deliverable";
+        }>;
+        title: z.ZodOptional<z.ZodString>;
+        pinned: z.ZodBoolean;
+        retrievalPolicy: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdBy: z.ZodObject<{
+            kind: z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                system: "system";
+                integration: "integration";
+            }>;
+            id: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function registerTaskRelationCapabilities(dispatcher: CapabilityDispatcher, wake?: (runs: boolean) => void): void;

package/dist/src/tasks/capabilities/relations.js

@@ -0,0 +1,140 @@
+import { getSqliteDatabase, init_transaction } from "../../storage/sqlite/transaction.js";
+import { TaskContextEdgeSchema, TaskContextInputSchema, TaskDependencySummarySchema, TaskDependencyUpdateRequestSchema, TaskDetailResponseSchema } from "../../../packages/gateway-contract/src/tasks.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { enqueueTaskChangedEvent, init_task_change_events } from "../task-change-events.js";
+import { TaskRepository, init_task_repository } from "../task-repository.js";
+import { CapabilityError } from "../../capabilities/runtime/errors.js";
+import { defineAtomicCapability } from "../../capabilities/runtime/dispatcher.js";
+import { TaskContextRepository } from "../task-context-repository.js";
+import { TaskDependencyError, TaskDependencyService } from "../task-dependency-service.js";
+import { z } from "zod";
+//#region src/tasks/capabilities/relations.ts
+init_src();
+init_transaction();
+init_task_change_events();
+init_task_repository();
+const TaskDependenciesOutputSchema = z.object({
+	ok: z.literal(true),
+	task: TaskDetailResponseSchema.shape.task,
+	dependencies: z.array(TaskDependencySummarySchema),
+	dependents: z.array(TaskDependencySummarySchema)
+});
+const TaskContextMutationOutputSchema = z.object({
+	ok: z.literal(true),
+	taskId: z.string(),
+	edgeId: z.string(),
+	version: z.number().int().positive(),
+	edge: TaskContextEdgeSchema.optional(),
+	context: z.array(TaskContextEdgeSchema)
+});
+function registerTaskRelationCapabilities(dispatcher, wake) {
+	const tasks = new TaskRepository();
+	const dependencies = new TaskDependencyService();
+	const context = new TaskContextRepository();
+	const policy = {
+		majorVersion: 1,
+		effect: "local-write",
+		surfaces: ["http", "agent"],
+		scopes: ["tasks.write"],
+		afterCommit: () => wake?.(false)
+	};
+	dispatcher.register(defineAtomicCapability({
+		...policy,
+		id: "xopc.tasks.update_dependencies",
+		description: "Replace dependencies at an exact task version.",
+		input: TaskDependencyUpdateRequestSchema.extend({ taskId: z.string().min(1) }),
+		output: TaskDependenciesOutputSchema,
+		execute(input, caller) {
+			try {
+				const task = dependencies.replace(input);
+				enqueueTaskChangedEvent(getSqliteDatabase(), {
+					taskId: task.id,
+					projectId: task.projectId,
+					version: task.version,
+					changedFields: ["dependencies"],
+					actor: caller.actor
+				});
+				return {
+					ok: true,
+					task,
+					dependencies: dependencies.listDependencies(task.id),
+					dependents: dependencies.listDependents(task.id)
+				};
+			} catch (error) {
+				if (error instanceof TaskDependencyError) throw new CapabilityError(error.code === "not_found" ? "NOT_FOUND" : error.code === "conflict" ? "REVISION_CONFLICT" : "INVALID_INPUT", error.message);
+				throw error;
+			}
+		}
+	}));
+	dispatcher.register(defineAtomicCapability({
+		...policy,
+		id: "xopc.tasks.add_context",
+		description: "Attach task context once and advance the task revision.",
+		input: z.strictObject({
+			taskId: z.string().min(1),
+			edge: TaskContextInputSchema,
+			expectedVersion: z.number().int().positive().optional()
+		}),
+		output: TaskContextMutationOutputSchema,
+		execute(input, caller) {
+			const task = tasks.get(input.taskId);
+			if (!task) throw new CapabilityError("NOT_FOUND", "Task not found");
+			const updated = tasks.update(task.id, { expectedVersion: input.expectedVersion ?? task.version });
+			if (!updated) throw new CapabilityError("REVISION_CONFLICT", "Task changed");
+			const edge = context.add({
+				taskId: task.id,
+				...input.edge,
+				createdBy: caller.actor ?? { kind: "system" }
+			});
+			enqueueTaskChangedEvent(getSqliteDatabase(), {
+				taskId: task.id,
+				projectId: task.projectId,
+				version: updated.version,
+				changedFields: ["context"],
+				actor: caller.actor
+			});
+			return {
+				ok: true,
+				taskId: task.id,
+				edgeId: edge.id,
+				edge,
+				version: updated.version,
+				context: context.list(task.id)
+			};
+		}
+	}));
+	dispatcher.register(defineAtomicCapability({
+		...policy,
+		id: "xopc.tasks.remove_context",
+		description: "Remove a task context edge once and advance the task revision.",
+		input: z.strictObject({
+			taskId: z.string().min(1),
+			edgeId: z.string().min(1),
+			expectedVersion: z.number().int().positive().optional()
+		}),
+		output: TaskContextMutationOutputSchema,
+		execute(input, caller) {
+			const task = tasks.get(input.taskId);
+			if (!task) throw new CapabilityError("NOT_FOUND", "Task not found");
+			const updated = tasks.update(task.id, { expectedVersion: input.expectedVersion ?? task.version });
+			if (!updated) throw new CapabilityError("REVISION_CONFLICT", "Task changed");
+			if (!context.remove(task.id, input.edgeId)) throw new CapabilityError("NOT_FOUND", "Task context edge not found");
+			enqueueTaskChangedEvent(getSqliteDatabase(), {
+				taskId: task.id,
+				projectId: task.projectId,
+				version: updated.version,
+				changedFields: ["context"],
+				actor: caller.actor
+			});
+			return {
+				ok: true,
+				taskId: task.id,
+				edgeId: input.edgeId,
+				version: updated.version,
+				context: context.list(task.id)
+			};
+		}
+	}));
+}
+//#endregion
+export { TaskContextMutationOutputSchema, TaskDependenciesOutputSchema, registerTaskRelationCapabilities };

package/dist/src/tasks/capabilities/runs.d.ts

@@ -0,0 +1,2 @@
+import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+export declare function registerTaskRunWriteCapabilities(dispatcher: CapabilityDispatcher, wake?: (runs: boolean) => void): void;

package/dist/src/tasks/capabilities/runs.js

@@ -0,0 +1,89 @@
+import { TaskRunCancelInputSchema, TaskRunCancelOutputSchema, TaskRunFeedbackInputSchema, TaskRunFeedbackOutputSchema } from "../../../packages/gateway-contract/src/capabilities.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { TaskRepository, init_task_repository } from "../task-repository.js";
+import { TaskRunRepository, init_task_run_repository } from "../task-run-repository.js";
+import { CapabilityError } from "../../capabilities/runtime/errors.js";
+import { defineAtomicCapability } from "../../capabilities/runtime/dispatcher.js";
+import { TaskApplicationService } from "../task-application-service.js";
+//#region src/tasks/capabilities/runs.ts
+init_src();
+init_task_repository();
+init_task_run_repository();
+function registerTaskRunWriteCapabilities(dispatcher, wake) {
+	dispatcher.register(defineAtomicCapability({
+		id: "xopc.task_runs.feedback",
+		majorVersion: 1,
+		description: "Record feedback for one task run exactly once per intent.",
+		effect: "local-write",
+		surfaces: ["http", "agent"],
+		scopes: ["tasks.write"],
+		input: TaskRunFeedbackInputSchema,
+		output: TaskRunFeedbackOutputSchema,
+		execute({ id, rating, reason }, context) {
+			const runs = new TaskRunRepository();
+			if (!runs.get(id)) throw new CapabilityError("NOT_FOUND", "TaskRun not found");
+			return {
+				ok: true,
+				feedback: runs.recordFeedback({
+					runId: id,
+					rating,
+					reason,
+					actor: context.actor
+				})
+			};
+		},
+		afterCommit() {
+			wake?.(false);
+		}
+	}));
+	dispatcher.register(defineAtomicCapability({
+		id: "xopc.task_runs.cancel",
+		majorVersion: 1,
+		description: "Finalize a task run as logically cancelled at an exact version. This receipt does not confirm external execution has stopped.",
+		effect: "local-write",
+		surfaces: ["http", "agent"],
+		scopes: ["tasks.write"],
+		input: TaskRunCancelInputSchema,
+		output: TaskRunCancelOutputSchema,
+		execute({ id, expectedVersion, reason }, context) {
+			const runs = new TaskRunRepository();
+			const run = runs.get(id);
+			if (!run) throw new CapabilityError("NOT_FOUND", "TaskRun not found");
+			if (run.version !== expectedVersion) throw new CapabilityError("REVISION_CONFLICT", "TaskRun changed");
+			const task = new TaskRepository().require(run.taskId);
+			const result = new TaskApplicationService().completeRun({
+				runId: id,
+				expectedRunVersion: expectedVersion,
+				actor: context.actor,
+				terminalCode: context.actor?.kind === "agent" ? "cancelled_by_agent" : "cancelled_by_user",
+				terminalMessage: reason,
+				receipt: {
+					status: "cancelled",
+					summary: reason,
+					changes: [],
+					evidence: [],
+					verification: {
+						status: "unverified",
+						checks: []
+					},
+					remainingWork: [task.contract?.objective ?? task.title],
+					needsUser: false,
+					completionVerdict: "not_achieved"
+				}
+			});
+			if (!result.ok) throw new CapabilityError("REVISION_CONFLICT", "TaskRun cannot be cancelled in its current state");
+			return {
+				ok: true,
+				run: runs.require(id),
+				receipt: runs.getReceipt(id),
+				model: result.model,
+				executionStopConfirmed: false
+			};
+		},
+		afterCommit() {
+			wake?.(false);
+		}
+	}));
+}
+//#endregion
+export { registerTaskRunWriteCapabilities };

package/dist/src/tasks/capabilities/write.d.ts

@@ -0,0 +1,207 @@
+import { z } from 'zod';
+import { type CapabilityDispatcher } from '../../capabilities/runtime/dispatcher.js';
+import type { Config } from '../../config/schema.js';
+import type { ProjectService } from '../../projects/index.js';
+export declare const TaskMutationOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    model: z.ZodObject<{
+        task: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            body: z.ZodOptional<z.ZodString>;
+            phase: z.ZodEnum<{
+                backlog: "backlog";
+                ready: "ready";
+                active: "active";
+                review: "review";
+                closed: "closed";
+            }>;
+            resolution: z.ZodOptional<z.ZodEnum<{
+                cancelled: "cancelled";
+                done: "done";
+                duplicate: "duplicate";
+                wont_do: "wont_do";
+            }>>;
+            priority: z.ZodEnum<{
+                low: "low";
+                normal: "normal";
+                high: "high";
+                critical: "critical";
+            }>;
+            dueAt: z.ZodOptional<z.ZodNumber>;
+            projectId: z.ZodOptional<z.ZodString>;
+            milestoneId: z.ZodOptional<z.ZodString>;
+            parentTaskId: z.ZodOptional<z.ZodString>;
+            ownerId: z.ZodOptional<z.ZodString>;
+            delegateAgentId: z.ZodOptional<z.ZodString>;
+            source: z.ZodString;
+            locale: z.ZodOptional<z.ZodEnum<{
+                en: "en";
+                zh: "zh";
+            }>>;
+            latestContractVersion: z.ZodNumber;
+            boardRank: z.ZodDefault<z.ZodNumber>;
+            version: z.ZodNumber;
+            contract: z.ZodOptional<z.ZodObject<{
+                taskId: z.ZodString;
+                version: z.ZodNumber;
+                objective: z.ZodString;
+                expectedOutputs: z.ZodArray<z.ZodString>;
+                acceptanceCriteria: z.ZodArray<z.ZodString>;
+                constraints: z.ZodArray<z.ZodString>;
+                approvalRequired: z.ZodArray<z.ZodString>;
+                assumptions: z.ZodArray<z.ZodString>;
+                risks: z.ZodArray<z.ZodString>;
+                acceptancePolicy: z.ZodEnum<{
+                    verified_auto: "verified_auto";
+                    verified_then_review: "verified_then_review";
+                    manual: "manual";
+                }>;
+                outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                createdBy: z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        user: "user";
+                        agent: "agent";
+                        system: "system";
+                        integration: "integration";
+                    }>;
+                    id: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                createdAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            closedAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        attention: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                input_required: "input_required";
+                approval_required: "approval_required";
+                dependency_blocked: "dependency_blocked";
+                run_failed: "run_failed";
+                verification_failed: "verification_failed";
+                overdue: "overdue";
+                stale: "stale";
+            }>;
+            summary: z.ZodString;
+            sourceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        operationalState: z.ZodEnum<{
+            waiting: "waiting";
+            idle: "idle";
+            queued: "queued";
+            running: "running";
+            verifying: "verifying";
+            blocked: "blocked";
+        }>;
+        allowedCommands: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    runId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    reason: z.ZodEnum<{
+        blocked: "blocked";
+        conflict: "conflict";
+        not_found: "not_found";
+        invalid_transition: "invalid_transition";
+    }>;
+    model: z.ZodOptional<z.ZodObject<{
+        task: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            body: z.ZodOptional<z.ZodString>;
+            phase: z.ZodEnum<{
+                backlog: "backlog";
+                ready: "ready";
+                active: "active";
+                review: "review";
+                closed: "closed";
+            }>;
+            resolution: z.ZodOptional<z.ZodEnum<{
+                cancelled: "cancelled";
+                done: "done";
+                duplicate: "duplicate";
+                wont_do: "wont_do";
+            }>>;
+            priority: z.ZodEnum<{
+                low: "low";
+                normal: "normal";
+                high: "high";
+                critical: "critical";
+            }>;
+            dueAt: z.ZodOptional<z.ZodNumber>;
+            projectId: z.ZodOptional<z.ZodString>;
+            milestoneId: z.ZodOptional<z.ZodString>;
+            parentTaskId: z.ZodOptional<z.ZodString>;
+            ownerId: z.ZodOptional<z.ZodString>;
+            delegateAgentId: z.ZodOptional<z.ZodString>;
+            source: z.ZodString;
+            locale: z.ZodOptional<z.ZodEnum<{
+                en: "en";
+                zh: "zh";
+            }>>;
+            latestContractVersion: z.ZodNumber;
+            boardRank: z.ZodDefault<z.ZodNumber>;
+            version: z.ZodNumber;
+            contract: z.ZodOptional<z.ZodObject<{
+                taskId: z.ZodString;
+                version: z.ZodNumber;
+                objective: z.ZodString;
+                expectedOutputs: z.ZodArray<z.ZodString>;
+                acceptanceCriteria: z.ZodArray<z.ZodString>;
+                constraints: z.ZodArray<z.ZodString>;
+                approvalRequired: z.ZodArray<z.ZodString>;
+                assumptions: z.ZodArray<z.ZodString>;
+                risks: z.ZodArray<z.ZodString>;
+                acceptancePolicy: z.ZodEnum<{
+                    verified_auto: "verified_auto";
+                    verified_then_review: "verified_then_review";
+                    manual: "manual";
+                }>;
+                outputDestinations: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                createdBy: z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        user: "user";
+                        agent: "agent";
+                        system: "system";
+                        integration: "integration";
+                    }>;
+                    id: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                createdAt: z.ZodNumber;
+            }, z.core.$strip>>;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            closedAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        attention: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                input_required: "input_required";
+                approval_required: "approval_required";
+                dependency_blocked: "dependency_blocked";
+                run_failed: "run_failed";
+                verification_failed: "verification_failed";
+                overdue: "overdue";
+                stale: "stale";
+            }>;
+            summary: z.ZodString;
+            sourceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        operationalState: z.ZodEnum<{
+            waiting: "waiting";
+            idle: "idle";
+            queued: "queued";
+            running: "running";
+            verifying: "verifying";
+            blocked: "blocked";
+        }>;
+        allowedCommands: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "ok">;
+export interface TaskWriteCapabilityDeps {
+    getConfig?: () => Config | undefined;
+    getProjects?: () => ProjectService | undefined;
+    wake?: (runs: boolean) => void;
+    abortConversation?: (conversationId: string) => void | Promise<void>;
+}
+export declare function registerTaskWriteCapabilities(dispatcher: CapabilityDispatcher, deps: TaskWriteCapabilityDeps): void;