@getforgeai/protocol 0.1.0-beta.1

package/dist/validation/mcp-tools.schema.js

@@ -0,0 +1,248 @@
+import { z } from "zod";
+import { KANBAN_SUB_STATUS } from "../constants/task-status.js";
+// --- forge_get_task ---
+export const ForgeGetTaskInputSchema = z.object({
+    taskId: z.string().min(1, "taskId is required"),
+});
+export const ForgeGetTaskOutputSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    description: z.string(),
+    completed: z.boolean(),
+    kanbanSubStatus: z.string().nullable().optional(),
+    acceptanceCriteria: z.string().optional(),
+    checkpoints: z.array(z.string()).optional(),
+    handoffContext: z.string().optional(),
+    assigneeId: z.string().nullable().optional(),
+    cliDeviceId: z.string().nullable().optional(),
+});
+// --- forge_update_status ---
+export const ForgeUpdateStatusInputSchema = z.object({
+    taskId: z.string().min(1, "taskId is required"),
+    kanbanSubStatus: z.enum(KANBAN_SUB_STATUS),
+});
+export const ForgeUpdateStatusOutputSchema = z.object({
+    taskId: z.string(),
+    previousStatus: z.string(),
+    newStatus: z.string(),
+    success: z.boolean(),
+});
+// --- forge_ask_human ---
+export const ForgeAskHumanInputSchema = z.object({
+    taskId: z.string().min(1, "taskId is required"),
+    question: z.string().min(1, "question is required"),
+    context: z.string().optional(),
+});
+export const ForgeAskHumanOutputSchema = z.object({
+    taskId: z.string(),
+    status: z.literal("waiting"),
+    message: z.string(),
+});
+// --- forge_requeue ---
+export const ForgeRequeueInputSchema = z.object({
+    taskId: z.string().min(1, "taskId is required"),
+    reason: z.string().optional(),
+});
+export const TaskRequeueResponseSchema = z.object({
+    allowed: z.boolean(),
+    count: z.number(),
+    max: z.number(),
+    reason: z.string().optional(),
+});
+// --- forge_complete_step (Story 6b.4) ---
+export const ForgeCompleteStepDeliverableSchema = z.object({
+    filePath: z.string().min(1, "filePath is required"),
+    label: z.string().min(1, "label is required"),
+    content: z.string().max(102_400).optional(),
+});
+export const ForgeCompleteStepInputSchema = z.object({
+    deliverables: z
+        .array(ForgeCompleteStepDeliverableSchema)
+        .min(1, "At least one deliverable is required"),
+});
+export const ForgeCompleteStepPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    workflowId: z.string(),
+    stepId: z.string(),
+    deliverables: z.array(ForgeCompleteStepDeliverableSchema).min(1),
+    timestamp: z.string(),
+});
+// --- agent:status Socket.io payload (Story 6.5 — Zod validation for runtime safety) ---
+export const AgentStatusPayloadSchema = z.object({
+    agentId: z.string(),
+    status: z.enum(["RUNNING", "COMPLETED", "ERROR", "QUEUED"]),
+    orgId: z.string(),
+    projectId: z.string().optional(),
+    timestamp: z.string(),
+});
+// --- agent:stream Socket.io payload (Story 6.6 — Zod validation for runtime safety) ---
+export const AgentStreamPayloadSchema = z.object({
+    agentId: z.string(),
+    chunk: z.string().max(8192),
+    turnIndex: z.number().int().optional(),
+    orgId: z.string(),
+    projectId: z.string().optional(),
+    timestamp: z.string(),
+});
+export const AgentToolActivityPayloadSchema = z.object({
+    agentId: z.string(),
+    toolName: z.string(),
+    toolDetail: z.string().max(200),
+    toolUseId: z.string().optional(),
+    parentToolUseId: z.string().optional(),
+    orgId: z.string(),
+    projectId: z.string(),
+    timestamp: z.string(),
+});
+// --- Socket.io event payloads for new events ---
+export const TaskAskHumanPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string().optional(),
+    timestamp: z.string(),
+    taskId: z.string(),
+    question: z.string(),
+    agentId: z.string().optional(),
+    context: z.string().optional(),
+});
+// --- forge_create_task_group (Story 6b.4b) ---
+export const ForgeCreateTaskGroupInputSchema = z.object({
+    name: z.string().min(1).max(100),
+    description: z.string().max(500).optional(),
+    order: z.number().int().min(0).optional(),
+});
+export const ForgeCreateTaskGroupPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    workflowId: z.string().optional(),
+    name: z.string().min(1).max(100),
+    description: z.string().max(500).optional(),
+    order: z.number().int().min(0).optional(),
+    timestamp: z.string(),
+});
+// --- forge_add_group_dependency (Story 6b.4b) ---
+export const ForgeAddGroupDependencyInputSchema = z.object({
+    blockingGroupName: z.string().min(1),
+    blockedGroupName: z.string().min(1),
+});
+export const ForgeAddGroupDependencyPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    workflowId: z.string().optional(),
+    blockingGroupName: z.string().min(1),
+    blockedGroupName: z.string().min(1),
+    timestamp: z.string(),
+});
+// --- forge_create_task (Story 6b.4b) ---
+export const ForgeCreateTaskInputSchema = z.object({
+    title: z.string().min(2).max(200),
+    description: z.string().min(1),
+    priority: z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]),
+    storyPoints: z.number().int().min(1).max(100),
+    groupName: z.string().optional(),
+    order: z.number().int().min(0).optional(),
+});
+export const ForgeCreateTaskPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    workflowId: z.string().optional(),
+    title: z.string().min(2).max(200),
+    description: z.string().min(1),
+    priority: z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]),
+    storyPoints: z.number().int().min(1).max(100),
+    groupName: z.string().optional(),
+    order: z.number().int().min(0).optional(),
+    timestamp: z.string(),
+});
+// --- forge_add_task_dependency (Story 6b.4b) ---
+export const ForgeAddTaskDependencyInputSchema = z.object({
+    blockingTaskTitle: z.string().min(1),
+    blockedTaskTitle: z.string().min(1),
+});
+export const ForgeAddTaskDependencyPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    workflowId: z.string().optional(),
+    blockingTaskTitle: z.string().min(1),
+    blockedTaskTitle: z.string().min(1),
+    timestamp: z.string(),
+});
+// --- forge_update_task (CRUD extension) ---
+export const ForgeUpdateTaskInputSchema = z.object({
+    name: z.string().min(1, "Task name/title is required"),
+    title: z.string().min(2).max(200).optional(),
+    description: z.string().min(1).optional(),
+    priority: z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]).optional(),
+    storyPoints: z.number().int().min(1).max(100).optional(),
+});
+export const ForgeUpdateTaskPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    name: z.string().min(1),
+    title: z.string().min(2).max(200).optional(),
+    description: z.string().min(1).optional(),
+    priority: z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]).optional(),
+    storyPoints: z.number().int().min(1).max(100).optional(),
+    timestamp: z.string(),
+});
+// --- forge_delete_task (CRUD extension) ---
+export const ForgeDeleteTaskInputSchema = z.object({
+    name: z.string().min(1, "Task name/title is required"),
+});
+export const ForgeDeleteTaskPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    name: z.string().min(1),
+    timestamp: z.string(),
+});
+// --- forge_update_task_group (CRUD extension) ---
+export const ForgeUpdateTaskGroupInputSchema = z.object({
+    name: z.string().min(1, "Current group name is required"),
+    newName: z.string().min(1).max(100).optional(),
+    description: z.string().max(500).optional(),
+});
+export const ForgeUpdateTaskGroupPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    name: z.string().min(1),
+    newName: z.string().min(1).max(100).optional(),
+    description: z.string().max(500).optional(),
+    timestamp: z.string(),
+});
+// --- forge_delete_task_group (CRUD extension) ---
+export const ForgeDeleteTaskGroupInputSchema = z.object({
+    name: z.string().min(1, "Group name is required"),
+});
+export const ForgeDeleteTaskGroupPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    name: z.string().min(1),
+    timestamp: z.string(),
+});
+// --- forge_remove_task_dependency (CRUD extension) ---
+export const ForgeRemoveTaskDependencyInputSchema = z.object({
+    taskName: z.string().min(1, "Task name/title is required"),
+    dependsOnTaskName: z
+        .string()
+        .min(1, "Dependency task name/title is required"),
+});
+export const ForgeRemoveTaskDependencyPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    taskName: z.string().min(1),
+    dependsOnTaskName: z.string().min(1),
+    timestamp: z.string(),
+});
+// --- forge_remove_group_dependency (CRUD extension) ---
+export const ForgeRemoveGroupDependencyInputSchema = z.object({
+    groupName: z.string().min(1, "Group name is required"),
+    dependsOnGroupName: z.string().min(1, "Dependency group name is required"),
+});
+export const ForgeRemoveGroupDependencyPayloadSchema = z.object({
+    orgId: z.string(),
+    projectId: z.string(),
+    groupName: z.string().min(1),
+    dependsOnGroupName: z.string().min(1),
+    timestamp: z.string(),
+});
+//# sourceMappingURL=mcp-tools.schema.js.map

package/dist/validation/release.schema.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export declare const CreateReleaseSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        RELEASE: "RELEASE";
+        MERGE_BACK: "MERGE_BACK";
+    }>;
+    targetBranch: z.ZodString;
+    workflowIds: z.ZodArray<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateRelease = z.infer<typeof CreateReleaseSchema>;
+export declare const UpdateReleaseStatusSchema: z.ZodObject<{
+    releaseId: z.ZodString;
+    status: z.ZodEnum<{
+        PREPARING: "PREPARING";
+        REVIEW: "REVIEW";
+        RELEASING: "RELEASING";
+        RELEASED: "RELEASED";
+        FAILED: "FAILED";
+        CANCELLED: "CANCELLED";
+    }>;
+}, z.core.$strip>;
+export type UpdateReleaseStatus = z.infer<typeof UpdateReleaseStatusSchema>;
+export declare const ReleaseMergeProgressSchema: z.ZodObject<{
+    releaseId: z.ZodString;
+    branch: z.ZodString;
+    status: z.ZodEnum<{
+        merged: "merged";
+        conflict: "conflict";
+        failed: "failed";
+    }>;
+}, z.core.$strip>;
+export type ReleaseMergeProgress = z.infer<typeof ReleaseMergeProgressSchema>;
+export declare const ReleaseReadySchema: z.ZodObject<{
+    releaseId: z.ZodString;
+    testsStatus: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        passed: "passed";
+    }>;
+    conflictsResolved: z.ZodNumber;
+}, z.core.$strip>;
+export type ReleaseReady = z.infer<typeof ReleaseReadySchema>;
+export declare const ReleaseFinalizedSchema: z.ZodObject<{
+    releaseId: z.ZodString;
+    tagName: z.ZodOptional<z.ZodString>;
+    mergeCommit: z.ZodString;
+}, z.core.$strip>;
+export type ReleaseFinalized = z.infer<typeof ReleaseFinalizedSchema>;
+//# sourceMappingURL=release.schema.d.ts.map

package/dist/validation/release.schema.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { RELEASE_STATUS } from "../constants/release-status.js";
+import { RELEASE_TYPE } from "../constants/release-status.js";
+export const CreateReleaseSchema = z.object({
+    type: z.enum(RELEASE_TYPE),
+    targetBranch: z.string().min(1),
+    workflowIds: z.array(z.string().min(1)).min(1),
+    version: z.string().optional(),
+});
+export const UpdateReleaseStatusSchema = z.object({
+    releaseId: z.string().min(1),
+    status: z.enum(RELEASE_STATUS),
+});
+export const ReleaseMergeProgressSchema = z.object({
+    releaseId: z.string().min(1),
+    branch: z.string().min(1),
+    status: z.enum(["merged", "conflict", "failed"]),
+});
+export const ReleaseReadySchema = z.object({
+    releaseId: z.string().min(1),
+    testsStatus: z.enum(["pending", "passed", "failed"]),
+    conflictsResolved: z.number().int().min(0),
+});
+export const ReleaseFinalizedSchema = z.object({
+    releaseId: z.string().min(1),
+    tagName: z.string().optional(),
+    mergeCommit: z.string().min(1),
+});
+//# sourceMappingURL=release.schema.js.map

package/dist/validation/skill-pull.schema.d.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+export declare const WORKFLOW_APPLICABILITY_VALUES: readonly ["GREENFIELD", "BROWNFIELD_MAJOR", "BROWNFIELD_MINOR", "BROWNFIELD_PATCH", "MERGE_BACK", "RELEASE"];
+export declare const WorkflowApplicabilitySchema: z.ZodEnum<{
+    RELEASE: "RELEASE";
+    MERGE_BACK: "MERGE_BACK";
+    GREENFIELD: "GREENFIELD";
+    BROWNFIELD_MAJOR: "BROWNFIELD_MAJOR";
+    BROWNFIELD_MINOR: "BROWNFIELD_MINOR";
+    BROWNFIELD_PATCH: "BROWNFIELD_PATCH";
+}>;
+export type WorkflowApplicability = z.infer<typeof WorkflowApplicabilitySchema>;
+export declare const WORKFLOW_APPLICABILITY_LABELS: Record<WorkflowApplicability, string>;
+export declare const SkillWorkflowStepSchema: z.ZodObject<{
+    key: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    isOptional: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SkillWorkflowStep = z.infer<typeof SkillWorkflowStepSchema>;
+export declare const SkillWorkflowPipelineColumnSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type SkillWorkflowPipelineColumn = z.infer<typeof SkillWorkflowPipelineColumnSchema>;
+export declare const SkillWorkflowSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    applicability: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        RELEASE: "RELEASE";
+        MERGE_BACK: "MERGE_BACK";
+        GREENFIELD: "GREENFIELD";
+        BROWNFIELD_MAJOR: "BROWNFIELD_MAJOR";
+        BROWNFIELD_MINOR: "BROWNFIELD_MINOR";
+        BROWNFIELD_PATCH: "BROWNFIELD_PATCH";
+    }>>>>;
+    steps: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        isOptional: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    pipeline: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        command: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        order: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SkillWorkflow = z.infer<typeof SkillWorkflowSchema>;
+export declare const SkillPullResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodNumber;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+    workflows: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        applicability: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            RELEASE: "RELEASE";
+            MERGE_BACK: "MERGE_BACK";
+            GREENFIELD: "GREENFIELD";
+            BROWNFIELD_MAJOR: "BROWNFIELD_MAJOR";
+            BROWNFIELD_MINOR: "BROWNFIELD_MINOR";
+            BROWNFIELD_PATCH: "BROWNFIELD_PATCH";
+        }>>>>;
+        steps: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            title: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            command: z.ZodOptional<z.ZodString>;
+            isOptional: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        pipeline: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            command: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SkillPullResponse = z.infer<typeof SkillPullResponseSchema>;
+//# sourceMappingURL=skill-pull.schema.d.ts.map

package/dist/validation/skill-pull.schema.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+// --- Workflow Applicability ---
+export const WORKFLOW_APPLICABILITY_VALUES = [
+    "GREENFIELD",
+    "BROWNFIELD_MAJOR",
+    "BROWNFIELD_MINOR",
+    "BROWNFIELD_PATCH",
+    "MERGE_BACK",
+    "RELEASE",
+];
+export const WorkflowApplicabilitySchema = z.enum(WORKFLOW_APPLICABILITY_VALUES);
+export const WORKFLOW_APPLICABILITY_LABELS = {
+    GREENFIELD: "Greenfield",
+    BROWNFIELD_MAJOR: "Brownfield — Major",
+    BROWNFIELD_MINOR: "Brownfield — Minor",
+    BROWNFIELD_PATCH: "Brownfield — Patch",
+    MERGE_BACK: "Merge Back",
+    RELEASE: "Release",
+};
+// --- Skill Workflow schemas (Story 6b.1) ---
+export const SkillWorkflowStepSchema = z.object({
+    key: z.string().min(1),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    command: z.string().optional(),
+    isOptional: z.boolean().default(false),
+});
+export const SkillWorkflowPipelineColumnSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+    command: z.string().optional(),
+    color: z.string().optional(),
+    order: z.number().int().optional(),
+});
+export const SkillWorkflowSchema = z.object({
+    key: z.string().min(1),
+    name: z.string().min(1),
+    description: z.string().optional(),
+    applicability: z.array(WorkflowApplicabilitySchema).optional().default([]),
+    steps: z.array(SkillWorkflowStepSchema),
+    pipeline: z.array(SkillWorkflowPipelineColumnSchema),
+});
+// --- Skill Pull Response (Story 5d.2, updated Story 6b.1) ---
+export const SkillPullResponseSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    version: z.number().int().positive("Version must be a positive integer"),
+    files: z.array(z.object({
+        path: z.string().min(1, "File path cannot be empty"),
+        content: z.string().max(5_000_000, "File content exceeds 5MB limit"),
+    })),
+    workflows: z.array(SkillWorkflowSchema),
+});
+//# sourceMappingURL=skill-pull.schema.js.map

package/dist/validation/task-generation.schema.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+export declare const GeneratedTaskGroupSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    epicNumber: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type GeneratedTaskGroup = z.infer<typeof GeneratedTaskGroupSchema>;
+export declare const GeneratedTaskSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodString;
+    priority: z.ZodEnum<{
+        LOW: "LOW";
+        MEDIUM: "MEDIUM";
+        HIGH: "HIGH";
+        CRITICAL: "CRITICAL";
+    }>;
+    storyPoints: z.ZodNumber;
+    order: z.ZodNumber;
+    dependsOn: z.ZodArray<z.ZodNumber>;
+    groupIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type GeneratedTask = z.infer<typeof GeneratedTaskSchema>;
+export declare const TaskGenerationResultSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    projectId: z.ZodString;
+    groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        epicNumber: z.ZodOptional<z.ZodNumber>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        dependsOn: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodString;
+        priority: z.ZodEnum<{
+            LOW: "LOW";
+            MEDIUM: "MEDIUM";
+            HIGH: "HIGH";
+            CRITICAL: "CRITICAL";
+        }>;
+        storyPoints: z.ZodNumber;
+        order: z.ZodNumber;
+        dependsOn: z.ZodArray<z.ZodNumber>;
+        groupIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TaskGenerationResult = z.infer<typeof TaskGenerationResultSchema>;
+export declare const TaskGenerationRequestSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    skillName: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodArray<z.ZodObject<{
+        stepKey: z.ZodString;
+        title: z.ZodString;
+        fileName: z.ZodString;
+        filePath: z.ZodString;
+        artifactType: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TaskGenerationRequest = z.infer<typeof TaskGenerationRequestSchema>;
+//# sourceMappingURL=task-generation.schema.d.ts.map

package/dist/validation/task-generation.schema.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+// --- Generated Task Group (CLI → Cloud contract, Story 5b-4) ---
+export const GeneratedTaskGroupSchema = z.object({
+    name: z.string().min(1).max(100),
+    description: z.string().max(500).optional(),
+    epicNumber: z.number().int().positive().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    dependsOn: z.array(z.number().int().min(0)).default([]),
+});
+// --- Generated Task (CLI → Cloud contract) ---
+export const GeneratedTaskSchema = z.object({
+    title: z.string().min(2).max(200),
+    description: z.string(),
+    priority: z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]),
+    storyPoints: z.number().int().min(1).max(100),
+    order: z.number().int().min(0),
+    dependsOn: z.array(z.number().int().min(0)),
+    groupIndex: z.number().int().min(0).optional(),
+});
+// --- Task Generation Result (CLI POST body) ---
+export const TaskGenerationResultSchema = z.object({
+    workflowId: z.string(),
+    projectId: z.string(),
+    groups: z.array(GeneratedTaskGroupSchema).optional(),
+    tasks: z.array(GeneratedTaskSchema).min(1),
+});
+// --- Task Generation Request (Cloud → CLI via Socket.io) ---
+export const TaskGenerationRequestSchema = z.object({
+    workflowId: z.string(),
+    skillName: z.string().optional(),
+    artifacts: z.array(z.object({
+        stepKey: z.string(),
+        title: z.string(),
+        fileName: z.string(),
+        filePath: z.string(),
+        artifactType: z.string(),
+    })),
+});
+//# sourceMappingURL=task-generation.schema.js.map

package/dist/validation/task-worktree.schema.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export declare const TaskWorktreeCreateSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    taskSlug: z.ZodString;
+    projectSlug: z.ZodString;
+    workflowBaseBranch: z.ZodString;
+    repoUrl: z.ZodString;
+}, z.core.$strip>;
+export type TaskWorktreeCreate = z.infer<typeof TaskWorktreeCreateSchema>;
+export declare const TaskWorktreeCreatedSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    taskBranch: z.ZodString;
+    worktreePath: z.ZodString;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TaskWorktreeCreated = z.infer<typeof TaskWorktreeCreatedSchema>;
+export declare const TaskWorktreeCleanupSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    taskSlug: z.ZodString;
+    projectSlug: z.ZodString;
+    taskBranch: z.ZodString;
+    repoUrl: z.ZodString;
+}, z.core.$strip>;
+export type TaskWorktreeCleanup = z.infer<typeof TaskWorktreeCleanupSchema>;
+export declare const TaskWorktreeCleanedSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TaskWorktreeCleaned = z.infer<typeof TaskWorktreeCleanedSchema>;
+//# sourceMappingURL=task-worktree.schema.d.ts.map

package/dist/validation/task-worktree.schema.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+// --- Task Worktree Create (Cloud Server → CLI, Story 5c.2) ---
+export const TaskWorktreeCreateSchema = z.object({
+    taskId: z.string(),
+    taskSlug: z.string().min(1),
+    projectSlug: z.string().min(1),
+    workflowBaseBranch: z.string().min(1),
+    repoUrl: z.string().min(1),
+});
+// --- Task Worktree Created (CLI → Cloud Server, Story 5c.2) ---
+export const TaskWorktreeCreatedSchema = z.object({
+    taskId: z.string(),
+    taskBranch: z.string().min(1),
+    worktreePath: z.string().min(1),
+    success: z.boolean(),
+    error: z.string().optional(),
+});
+// --- Task Worktree Cleanup (Cloud Server → CLI, Story 5c.2) ---
+export const TaskWorktreeCleanupSchema = z.object({
+    taskId: z.string(),
+    taskSlug: z.string().min(1),
+    projectSlug: z.string().min(1),
+    taskBranch: z.string().min(1),
+    repoUrl: z.string().min(1),
+});
+// --- Task Worktree Cleaned (CLI → Cloud Server, Story 5c.2) ---
+export const TaskWorktreeCleanedSchema = z.object({
+    taskId: z.string(),
+    success: z.boolean(),
+    error: z.string().optional(),
+});
+//# sourceMappingURL=task-worktree.schema.js.map

package/dist/validation/workflow-branch.schema.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export declare const WorkflowBranchCreateSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    sourceBranch: z.ZodString;
+    baseBranch: z.ZodString;
+    repoUrl: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowBranchCreate = z.infer<typeof WorkflowBranchCreateSchema>;
+export declare const WorkflowBranchCreatedSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    baseBranch: z.ZodString;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WorkflowBranchCreated = z.infer<typeof WorkflowBranchCreatedSchema>;
+export declare const WorkflowBranchListRequestSchema: z.ZodObject<{
+    repoUrl: z.ZodString;
+    projectSlug: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WorkflowBranchListRequest = z.infer<typeof WorkflowBranchListRequestSchema>;
+export declare const WorkflowBranchListResponseSchema: z.ZodObject<{
+    branches: z.ZodArray<z.ZodString>;
+    defaultBranch: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowBranchListResponse = z.infer<typeof WorkflowBranchListResponseSchema>;
+//# sourceMappingURL=workflow-branch.schema.d.ts.map