@teamclaws/teamclaw 2026.3.26-2 → 2026.4.2-2

package/src/controller/orchestration-manifest.ts

@@ -1,4 +1,6 @@
 import type {
+  ClarificationQuestionOption,
+  ClarificationQuestionSchema,
   ControllerManifestCreatedTask,
   ControllerManifestDeferredTask,
   ControllerOrchestrationManifest,
@@ -53,6 +55,67 @@ export function normalizeOptionalManifestText(raw: unknown): string | undefined
   return normalized || undefined;
 }
 
+export function normalizeClarificationOptions(raw: unknown): ClarificationQuestionOption[] {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw
+    .filter((entry): entry is Record<string, unknown> => !!entry && typeof entry === "object")
+    .map((entry) => ({
+      value: typeof entry.value === "string" ? entry.value.trim() : "",
+      label: typeof entry.label === "string" ? entry.label.trim() : "",
+      hint: typeof entry.hint === "string" && entry.hint.trim() ? entry.hint.trim() : undefined,
+    }))
+    .filter((entry) => entry.value && entry.label);
+}
+
+export function normalizeClarificationQuestionSchema(raw: unknown): ClarificationQuestionSchema | undefined {
+  if (!raw || typeof raw !== "object") {
+    return undefined;
+  }
+  const input = raw as Record<string, unknown>;
+  const kind = typeof input.kind === "string" ? input.kind.trim() : "";
+  const title = typeof input.title === "string" ? input.title.trim() : "";
+  if (!title || !["single-select", "multi-select", "number", "text"].includes(kind)) {
+    return undefined;
+  }
+  const options = normalizeClarificationOptions(input.options);
+  const schema: ClarificationQuestionSchema = {
+    kind: kind as ClarificationQuestionSchema["kind"],
+    title,
+    description: normalizeOptionalManifestText(input.description),
+    required: input.required == null ? true : Boolean(input.required),
+    allowOther: Boolean(input.allowOther),
+    placeholder: normalizeOptionalManifestText(input.placeholder),
+    unit: normalizeOptionalManifestText(input.unit),
+  };
+  if (options.length > 0) {
+    schema.options = options;
+  }
+  if (typeof input.min === "number" && Number.isFinite(input.min)) {
+    schema.min = input.min;
+  }
+  if (typeof input.max === "number" && Number.isFinite(input.max)) {
+    schema.max = input.max;
+  }
+  if (typeof input.step === "number" && Number.isFinite(input.step)) {
+    schema.step = input.step;
+  }
+  if ((schema.kind === "single-select" || schema.kind === "multi-select") && (!schema.options || schema.options.length === 0)) {
+    return undefined;
+  }
+  return schema;
+}
+
+export function normalizeClarificationQuestionSchemas(raw: unknown): ClarificationQuestionSchema[] {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw
+    .map((entry) => normalizeClarificationQuestionSchema(entry))
+    .filter((entry): entry is ClarificationQuestionSchema => Boolean(entry));
+}
+
 export function normalizeManifestCreatedTasks(raw: unknown): ControllerManifestCreatedTask[] {
   if (!Array.isArray(raw)) {
     return [];
@@ -91,15 +154,20 @@ export function normalizeControllerManifest(raw: unknown): ControllerOrchestrati
   if (!requirementSummary) {
     return null;
   }
+  const clarificationSchemas = normalizeClarificationQuestionSchemas(input.clarificationSchemas);
+  const clarificationQuestions = normalizeManifestStringList(input.clarificationQuestions);
   return {
     version: typeof input.version === "string" && input.version.trim() ? input.version.trim() : "1.0",
+    projectName: typeof input.projectName === "string" && input.projectName.trim() ? input.projectName.trim() : undefined,
     requirementSummary,
     requiredRoles: normalizeManifestRoleList(input.requiredRoles),
     clarificationsNeeded: Boolean(input.clarificationsNeeded),
-    clarificationQuestions: normalizeManifestStringList(input.clarificationQuestions),
+    clarificationQuestions: clarificationQuestions.length > 0 ? clarificationQuestions : clarificationSchemas.map((entry) => entry.title),
+    clarificationSchemas,
     createdTasks: normalizeManifestCreatedTasks(input.createdTasks),
     deferredTasks: normalizeManifestDeferredTasks(input.deferredTasks),
     handoffPlan: normalizeOptionalManifestText(input.handoffPlan),
     notes: normalizeOptionalManifestText(input.notes),
+    requirementFullyComplete: Boolean(input.requirementFullyComplete),
   };
 }