@neuraloom/contracts 0.0.0-stage → 0.1.22

package/dist/schemas/ai/zod-openai-json-schema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOpenAiStrictJsonSchema = generateOpenAiStrictJsonSchema;
+/**
+ * Zod → OpenAI Responses API strict JSON Schema (fully inlined, required keys).
+ * Shared by workflow payload schemas and LLM output schemas.
+ */
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const zodToJsonSchema = zod_to_json_schema_1.zodToJsonSchema;
+function isJsonObject(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function isAlreadyNullable(node) {
+    if (Array.isArray(node["anyOf"])) {
+        return node["anyOf"].some((s) => isJsonObject(s) && s["type"] === "null");
+    }
+    return Array.isArray(node["type"]) && node["type"].includes("null");
+}
+function toOpenAiStrict(node) {
+    const result = { ...node };
+    // OpenAI structured output does not support JSON Schema format annotations
+    // (uri, uuid, email, date, time, date-time, etc.) — strip them unconditionally.
+    delete result["format"];
+    if (result["type"] === "object" && isJsonObject(result["properties"])) {
+        const props = result["properties"];
+        const required = new Set(Array.isArray(result["required"]) ? result["required"] : []);
+        const newProps = {};
+        for (const [key, val] of Object.entries(props)) {
+            if (!isJsonObject(val)) {
+                newProps[key] = val;
+                continue;
+            }
+            const processed = toOpenAiStrict(val);
+            if (required.has(key)) {
+                newProps[key] = processed;
+            }
+            else {
+                newProps[key] = isAlreadyNullable(processed)
+                    ? processed
+                    : { anyOf: [processed, { type: "null" }] };
+            }
+        }
+        result["properties"] = newProps;
+        result["required"] = Object.keys(newProps);
+        result["additionalProperties"] = false;
+    }
+    else if (result["type"] === "object" && isJsonObject(result["additionalProperties"])) {
+        result["additionalProperties"] = toOpenAiStrict(result["additionalProperties"]);
+    }
+    if (Array.isArray(result["anyOf"])) {
+        result["anyOf"] = result["anyOf"].map((s) => isJsonObject(s) ? toOpenAiStrict(s) : s);
+    }
+    if (Array.isArray(result["oneOf"])) {
+        result["oneOf"] = result["oneOf"].map((s) => isJsonObject(s) ? toOpenAiStrict(s) : s);
+    }
+    if (isJsonObject(result["items"])) {
+        result["items"] = toOpenAiStrict(result["items"]);
+    }
+    else if (Array.isArray(result["items"])) {
+        result["items"] = result["items"].map((s) => isJsonObject(s) ? toOpenAiStrict(s) : s);
+    }
+    return result;
+}
+function generateOpenAiStrictJsonSchema(schema) {
+    const raw = zodToJsonSchema(schema, { $refStrategy: "none", target: "jsonSchema7" });
+    return toOpenAiStrict(raw);
+}

package/dist/schemas/ai-ci-generate.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const AICIGenerateInputSchema: z.ZodEffects<z.ZodObject<{
+    projectId: z.ZodString;
+} & {
+    orchestrationId: z.ZodOptional<z.ZodString>;
+} & {
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["generate", "refine"]>>>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    mode: "generate" | "refine";
+    orchestrationId?: string | undefined;
+    instructions?: string | undefined;
+}, {
+    projectId: string;
+    mode?: "generate" | "refine" | undefined;
+    orchestrationId?: string | undefined;
+    instructions?: string | undefined;
+}>, {
+    projectId: string;
+    mode: "generate" | "refine";
+    orchestrationId?: string | undefined;
+    instructions?: string | undefined;
+}, {
+    projectId: string;
+    mode?: "generate" | "refine" | undefined;
+    orchestrationId?: string | undefined;
+    instructions?: string | undefined;
+}>;
+export declare const AICIGenerateDataSchema: z.ZodObject<{
+    yaml: z.ZodString;
+    description: z.ZodString;
+    stages: z.ZodArray<z.ZodString, "many">;
+    targetFilePath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    stages: string[];
+    yaml: string;
+    targetFilePath: string;
+}, {
+    description: string;
+    stages: string[];
+    yaml: string;
+    targetFilePath: string;
+}>;
+export type AICIGenerateInput = z.infer<typeof AICIGenerateInputSchema>;
+export type AICIGenerateData = z.infer<typeof AICIGenerateDataSchema>;

package/dist/schemas/ai-ci-generate.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AICIGenerateDataSchema = exports.AICIGenerateInputSchema = void 0;
+const zod_1 = require("zod");
+const refine_fields_schema_1 = require("./ai/refine-fields.schema");
+const orchestration_generate_fields_schema_1 = require("./ai/orchestration-generate-fields.schema");
+exports.AICIGenerateInputSchema = zod_1.z
+    .object({
+    projectId: zod_1.z.string().uuid(),
+})
+    .merge(orchestration_generate_fields_schema_1.AiGenerateOrchestrationIdOptionalSchema)
+    .merge(refine_fields_schema_1.RefineFieldsObject)
+    .superRefine(refine_fields_schema_1.refineFieldsSuperRefine);
+exports.AICIGenerateDataSchema = zod_1.z.object({
+    yaml: zod_1.z.string().min(1),
+    description: zod_1.z.string(),
+    stages: zod_1.z.array(zod_1.z.string()),
+    targetFilePath: zod_1.z.string().min(1),
+});

package/dist/schemas/ai-llm-outputs.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+/** Raw LLM output for AI CI step (path merged in the route) */
+export declare const AICILlmOutputSchema: z.ZodObject<{
+    yaml: z.ZodString;
+    description: z.ZodString;
+    stages: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    stages: string[];
+    yaml: string;
+}, {
+    description: string;
+    stages: string[];
+    yaml: string;
+}>;
+export type AICILlmOutput = z.infer<typeof AICILlmOutputSchema>;
+/** LLM output for the deployments / DevOps generate step */
+export declare const DeploymentLlmConfigSchema: z.ZodObject<{
+    vercelConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dockerConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    buildCommands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    envVars: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    vercelConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dockerConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    buildCommands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    envVars: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    vercelConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dockerConfig: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    buildCommands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    envVars: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+}, z.ZodTypeAny, "passthrough">>;
+export type DeploymentLlmConfig = z.infer<typeof DeploymentLlmConfigSchema>;
+/** LLM JSON block for the analytics generate route */
+export declare const AnalyticsWorkflowInsightsLlmSchema: z.ZodObject<{
+    insights: z.ZodArray<z.ZodString, "many">;
+    recommendations: z.ZodArray<z.ZodString, "many">;
+    riskAreas: z.ZodArray<z.ZodString, "many">;
+    strengths: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    insights: string[];
+    recommendations: string[];
+    riskAreas: string[];
+    strengths: string[];
+}, {
+    insights: string[];
+    recommendations: string[];
+    riskAreas: string[];
+    strengths: string[];
+}>;
+export type AnalyticsWorkflowInsightsLlm = z.infer<typeof AnalyticsWorkflowInsightsLlmSchema>;

package/dist/schemas/ai-llm-outputs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsWorkflowInsightsLlmSchema = exports.DeploymentLlmConfigSchema = exports.AICILlmOutputSchema = void 0;
+const zod_1 = require("zod");
+/** Raw LLM output for AI CI step (path merged in the route) */
+exports.AICILlmOutputSchema = zod_1.z.object({
+    yaml: zod_1.z.string(),
+    description: zod_1.z.string(),
+    stages: zod_1.z.array(zod_1.z.string()),
+});
+/** LLM output for the deployments / DevOps generate step */
+exports.DeploymentLlmConfigSchema = zod_1.z
+    .object({
+    vercelConfig: zod_1.z.record(zod_1.z.unknown()).optional(),
+    dockerConfig: zod_1.z.record(zod_1.z.unknown()).optional(),
+    buildCommands: zod_1.z.array(zod_1.z.string()).optional(),
+    envVars: zod_1.z.array(zod_1.z.unknown()).optional(),
+})
+    .passthrough();
+/** LLM JSON block for the analytics generate route */
+exports.AnalyticsWorkflowInsightsLlmSchema = zod_1.z.object({
+    insights: zod_1.z.array(zod_1.z.string()),
+    recommendations: zod_1.z.array(zod_1.z.string()),
+    riskAreas: zod_1.z.array(zod_1.z.string()),
+    strengths: zod_1.z.array(zod_1.z.string()),
+});

package/dist/schemas/api/create-orchestration-request.schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+/** POST /api/projects/[id]/orchestrations — body before AI generate for WorkflowRunConsole polling. */
+export declare const CreateOrchestrationRequestSchema: z.ZodObject<{
+    workflowStepId: z.ZodEnum<[string, ...string[]]>;
+    kind: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: string;
+    workflowStepId: string;
+}, {
+    kind: string;
+    workflowStepId: string;
+}>;
+export type CreateOrchestrationRequest = z.infer<typeof CreateOrchestrationRequestSchema>;

package/dist/schemas/api/create-orchestration-request.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateOrchestrationRequestSchema = void 0;
+const zod_1 = require("zod");
+const workflow_step_ids_schema_1 = require("../ai/model-policy/workflow-step-ids.schema");
+/** POST /api/projects/[id]/orchestrations — body before AI generate for WorkflowRunConsole polling. */
+exports.CreateOrchestrationRequestSchema = zod_1.z.object({
+    workflowStepId: workflow_step_ids_schema_1.WorkflowStepIdSchema,
+    kind: zod_1.z.string().min(1).max(200),
+});

package/dist/schemas/api/implement-orchestration-session.schema.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+/** POST /api/projects/[id]/orchestrations — creates an orchestrations row for WorkflowRunConsole polling. */
+export declare const CreateOrchestrationResponseSchema: z.ZodObject<{
+    orchestrationId: z.ZodString;
+    doesStartExecution: z.ZodLiteral<false>;
+}, "strip", z.ZodTypeAny, {
+    orchestrationId: string;
+    doesStartExecution: false;
+}, {
+    orchestrationId: string;
+    doesStartExecution: false;
+}>;
+export type CreateOrchestrationResponse = z.infer<typeof CreateOrchestrationResponseSchema>;
+/** @deprecated Prefer CreateOrchestrationResponseSchema */
+export declare const ImplementOrchestrationSessionResponseSchema: z.ZodObject<{
+    orchestrationId: z.ZodString;
+    doesStartExecution: z.ZodLiteral<false>;
+}, "strip", z.ZodTypeAny, {
+    orchestrationId: string;
+    doesStartExecution: false;
+}, {
+    orchestrationId: string;
+    doesStartExecution: false;
+}>;
+/** @deprecated Prefer CreateOrchestrationResponse */
+export type ImplementOrchestrationSessionResponse = CreateOrchestrationResponse;

package/dist/schemas/api/implement-orchestration-session.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImplementOrchestrationSessionResponseSchema = exports.CreateOrchestrationResponseSchema = void 0;
+const zod_1 = require("zod");
+/** POST /api/projects/[id]/orchestrations — creates an orchestrations row for WorkflowRunConsole polling. */
+exports.CreateOrchestrationResponseSchema = zod_1.z.object({
+    orchestrationId: zod_1.z.string().uuid(),
+    doesStartExecution: zod_1.z.literal(false),
+});
+/** @deprecated Prefer CreateOrchestrationResponseSchema */
+exports.ImplementOrchestrationSessionResponseSchema = exports.CreateOrchestrationResponseSchema;

package/dist/schemas/api/orchestration-events-list-response.schema.d.ts

@@ -0,0 +1,108 @@
+import { z } from "zod";
+/** Narrow UI subset of orchestration_events.meta for telemetry parsing (passthrough allows extra keys). */
+export declare const OrchestrationEventMetaRootSchema: z.ZodObject<{
+    workflowStepId: z.ZodOptional<z.ZodString>;
+    stageId: z.ZodOptional<z.ZodString>;
+    guardianScore: z.ZodOptional<z.ZodNumber>;
+    canonicalEvent: z.ZodOptional<z.ZodObject<{
+        step: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        step?: string | undefined;
+    }, {
+        step?: string | undefined;
+    }>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    workflowStepId: z.ZodOptional<z.ZodString>;
+    stageId: z.ZodOptional<z.ZodString>;
+    guardianScore: z.ZodOptional<z.ZodNumber>;
+    canonicalEvent: z.ZodOptional<z.ZodObject<{
+        step: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        step?: string | undefined;
+    }, {
+        step?: string | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    workflowStepId: z.ZodOptional<z.ZodString>;
+    stageId: z.ZodOptional<z.ZodString>;
+    guardianScore: z.ZodOptional<z.ZodNumber>;
+    canonicalEvent: z.ZodOptional<z.ZodObject<{
+        step: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        step?: string | undefined;
+    }, {
+        step?: string | undefined;
+    }>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type OrchestrationEventMetaRoot = z.infer<typeof OrchestrationEventMetaRootSchema>;
+export declare const OrchestrationEventRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    level: z.ZodEnum<["info", "warn", "error", "success"]>;
+    message: z.ZodString;
+    eventType: z.ZodNullable<z.ZodString>;
+    meta: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    message: string;
+    createdAt: string;
+    meta: Record<string, unknown> | null;
+    level: "info" | "success" | "error" | "warn";
+    eventType: string | null;
+}, {
+    id: string;
+    message: string;
+    createdAt: string;
+    meta: Record<string, unknown> | null;
+    level: "info" | "success" | "error" | "warn";
+    eventType: string | null;
+}>;
+export declare const OrchestrationEventsListResponseSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        createdAt: z.ZodString;
+        level: z.ZodEnum<["info", "warn", "error", "success"]>;
+        message: z.ZodString;
+        eventType: z.ZodNullable<z.ZodString>;
+        meta: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        message: string;
+        createdAt: string;
+        meta: Record<string, unknown> | null;
+        level: "info" | "success" | "error" | "warn";
+        eventType: string | null;
+    }, {
+        id: string;
+        message: string;
+        createdAt: string;
+        meta: Record<string, unknown> | null;
+        level: "info" | "success" | "error" | "warn";
+        eventType: string | null;
+    }>, "many">;
+    latestAt: z.ZodNullable<z.ZodString>;
+    stepId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    events: {
+        id: string;
+        message: string;
+        createdAt: string;
+        meta: Record<string, unknown> | null;
+        level: "info" | "success" | "error" | "warn";
+        eventType: string | null;
+    }[];
+    latestAt: string | null;
+    stepId?: string | undefined;
+}, {
+    events: {
+        id: string;
+        message: string;
+        createdAt: string;
+        meta: Record<string, unknown> | null;
+        level: "info" | "success" | "error" | "warn";
+        eventType: string | null;
+    }[];
+    latestAt: string | null;
+    stepId?: string | undefined;
+}>;
+export type OrchestrationEventsListResponse = z.infer<typeof OrchestrationEventsListResponseSchema>;

package/dist/schemas/api/orchestration-events-list-response.schema.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrchestrationEventsListResponseSchema = exports.OrchestrationEventRowSchema = exports.OrchestrationEventMetaRootSchema = void 0;
+const zod_1 = require("zod");
+const workflow_run_event_schema_1 = require("../workflow/workflow-run-event.schema");
+/** Narrow UI subset of orchestration_events.meta for telemetry parsing (passthrough allows extra keys). */
+exports.OrchestrationEventMetaRootSchema = zod_1.z
+    .object({
+    workflowStepId: zod_1.z.string().optional(),
+    stageId: zod_1.z.string().optional(),
+    guardianScore: zod_1.z.number().optional(),
+    canonicalEvent: zod_1.z.object({ step: zod_1.z.string().optional() }).optional(),
+})
+    .passthrough();
+exports.OrchestrationEventRowSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    createdAt: zod_1.z.string(),
+    level: workflow_run_event_schema_1.WorkflowRunEventLevelSchema,
+    message: zod_1.z.string(),
+    eventType: zod_1.z.string().nullable(),
+    meta: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable(),
+});
+exports.OrchestrationEventsListResponseSchema = zod_1.z.object({
+    events: zod_1.z.array(exports.OrchestrationEventRowSchema),
+    latestAt: zod_1.z.string().nullable(),
+    stepId: zod_1.z.string().optional(),
+});

package/dist/schemas/api/plans-list-response.schema.d.ts

@@ -0,0 +1,203 @@
+import { z } from "zod";
+/** GET /api/plans row (camelCase); includes richer UI fields omitted from core Plan mutation schema. */
+export declare const PlanListAssigneeSchema: z.ZodNullable<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodNull;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    avatar: null;
+}, {
+    id: string;
+    name: string;
+    avatar: null;
+}>>;
+export type PlanListAssignee = z.infer<typeof PlanListAssigneeSchema>;
+export declare const PlanListSpecSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+}, {
+    id: string;
+    title: string;
+}>;
+export type PlanListSpecSummary = z.infer<typeof PlanListSpecSummarySchema>;
+export declare const PlanApiListRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    specId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    estimatedHours: z.ZodNumber;
+    actualHours: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    status: z.ZodEnum<["draft", "approved", "in_progress", "completed", "blocked"]>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    assignedTo: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    overview: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    components: z.ZodOptional<z.ZodUnknown>;
+    spec: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string;
+    }, {
+        id: string;
+        title: string;
+    }>;
+    assignee: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        avatar: z.ZodNull;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        avatar: null;
+    }, {
+        id: string;
+        name: string;
+        avatar: null;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    description: string;
+    status: "completed" | "blocked" | "approved" | "draft" | "in_progress";
+    projectId: string;
+    createdAt: string;
+    spec: {
+        id: string;
+        title: string;
+    };
+    updatedAt: string;
+    dependencies: string[];
+    specId: string;
+    estimatedHours: number;
+    assignee: {
+        id: string;
+        name: string;
+        avatar: null;
+    } | null;
+    actualHours?: number | null | undefined;
+    assignedTo?: string | undefined;
+    overview?: string | null | undefined;
+    components?: unknown;
+}, {
+    id: string;
+    title: string;
+    description: string;
+    status: "completed" | "blocked" | "approved" | "draft" | "in_progress";
+    projectId: string;
+    createdAt: string;
+    spec: {
+        id: string;
+        title: string;
+    };
+    updatedAt: string;
+    dependencies: string[];
+    specId: string;
+    estimatedHours: number;
+    assignee: {
+        id: string;
+        name: string;
+        avatar: null;
+    } | null;
+    actualHours?: number | null | undefined;
+    assignedTo?: string | undefined;
+    overview?: string | null | undefined;
+    components?: unknown;
+}>;
+export type PlanApiListRow = z.infer<typeof PlanApiListRowSchema>;
+export declare const PlansListApiResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    specId: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    estimatedHours: z.ZodNumber;
+    actualHours: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    status: z.ZodEnum<["draft", "approved", "in_progress", "completed", "blocked"]>;
+    dependencies: z.ZodArray<z.ZodString, "many">;
+    assignedTo: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    overview: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    components: z.ZodOptional<z.ZodUnknown>;
+    spec: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string;
+    }, {
+        id: string;
+        title: string;
+    }>;
+    assignee: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        avatar: z.ZodNull;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        avatar: null;
+    }, {
+        id: string;
+        name: string;
+        avatar: null;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    description: string;
+    status: "completed" | "blocked" | "approved" | "draft" | "in_progress";
+    projectId: string;
+    createdAt: string;
+    spec: {
+        id: string;
+        title: string;
+    };
+    updatedAt: string;
+    dependencies: string[];
+    specId: string;
+    estimatedHours: number;
+    assignee: {
+        id: string;
+        name: string;
+        avatar: null;
+    } | null;
+    actualHours?: number | null | undefined;
+    assignedTo?: string | undefined;
+    overview?: string | null | undefined;
+    components?: unknown;
+}, {
+    id: string;
+    title: string;
+    description: string;
+    status: "completed" | "blocked" | "approved" | "draft" | "in_progress";
+    projectId: string;
+    createdAt: string;
+    spec: {
+        id: string;
+        title: string;
+    };
+    updatedAt: string;
+    dependencies: string[];
+    specId: string;
+    estimatedHours: number;
+    assignee: {
+        id: string;
+        name: string;
+        avatar: null;
+    } | null;
+    actualHours?: number | null | undefined;
+    assignedTo?: string | undefined;
+    overview?: string | null | undefined;
+    components?: unknown;
+}>, "many">;
+export type PlansListApiResponse = z.infer<typeof PlansListApiResponseSchema>;

package/dist/schemas/api/plans-list-response.schema.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlansListApiResponseSchema = exports.PlanApiListRowSchema = exports.PlanListSpecSummarySchema = exports.PlanListAssigneeSchema = void 0;
+const zod_1 = require("zod");
+/** GET /api/plans row (camelCase); includes richer UI fields omitted from core Plan mutation schema. */
+exports.PlanListAssigneeSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().uuid(),
+    name: zod_1.z.string(),
+    avatar: zod_1.z.null(),
+})
+    .nullable();
+exports.PlanListSpecSummarySchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+});
+exports.PlanApiListRowSchema = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    projectId: zod_1.z.string().uuid(),
+    specId: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    estimatedHours: zod_1.z.number().int().positive(),
+    actualHours: zod_1.z.number().int().min(0).nullable().optional(),
+    status: zod_1.z.enum(["draft", "approved", "in_progress", "completed", "blocked"]),
+    dependencies: zod_1.z.array(zod_1.z.string().uuid()),
+    assignedTo: zod_1.z.string().uuid().optional(),
+    createdAt: zod_1.z.string(),
+    updatedAt: zod_1.z.string(),
+    overview: zod_1.z.string().nullable().optional(),
+    components: zod_1.z.unknown().optional(),
+    spec: exports.PlanListSpecSummarySchema,
+    assignee: exports.PlanListAssigneeSchema,
+});
+exports.PlansListApiResponseSchema = zod_1.z.array(exports.PlanApiListRowSchema);