新增发布校准接口

src/app/api/__tests__/jobs.test.ts

@@ -19,10 +19,16 @@ vi.mock("../../../lib/llm/client", async () => {
 });
 
 import { POST as confirmFactCard } from "../jobs/[jobId]/confirm-fact-card/route";
+import { POST as scoreJob } from "../jobs/[jobId]/calibration/score/route";
 import { GET as downloadExport } from "../jobs/[jobId]/exports/[fileName]/route";
 import { POST as optimizeJob } from "../jobs/[jobId]/optimize/route";
+import {
+  GET as listPublications,
+  POST as createPublication,
+} from "../jobs/[jobId]/publications/route";
 import { GET as getJobProgress } from "../jobs/[jobId]/progress/route";
 import { POST as createJob } from "../jobs/route";
+import { POST as recordPerformance } from "../publications/[publicationId]/performance/route";
 
 const validFactCard = {
   company_full_name: "Example Technology Co., Ltd.",
@@ -243,6 +249,95 @@ describe("job API routes", () => {
     expect(body.timing.steps.every((step) => step.duration_ms >= 0)).toBe(true);
   });
 
+  it("scores a revision, registers publication, and records manual performance", async () => {
+    const { job } = await createJobFixture();
+    await confirmFactCard(
+      request(validFactCard),
+      params<{ jobId: string }>({ jobId: job.id }),
+    );
+    llmMocks.generateValidatedJson.mockReset();
+    llmMocks.generateValidatedJson
+      .mockResolvedValueOnce({
+        title: "示例科技 GEO 内容优化方案",
+        summary:
+          "Example Technology Co., Ltd. 面向市场团队提供 GEO optimization 服务。",
+        body_markdown:
+          "## 服务能力\nExample Technology Co., Ltd. 提供 GEO optimization 服务。\n## 可信依据\n保留事实卡中的8年经验。",
+        image_suggestions: [],
+        changed_sections: ["title", "body"],
+        requires_user_confirmation: [],
+      })
+      .mockResolvedValueOnce({ checks: [] });
+    const optimizeResponse = await optimizeJob(
+      request({}),
+      params<{ jobId: string }>({ jobId: job.id }),
+    );
+    const optimizeBody = (await optimizeResponse.json()) as unknown;
+    if (optimizeResponse.status !== 200) {
+      throw new Error(`optimize failed: ${JSON.stringify(optimizeBody)}`);
+    }
+
+    expect(optimizeResponse.status).toBe(200);
+
+    const scoreResponse = await scoreJob(
+      request({}),
+      params<{ jobId: string }>({ jobId: job.id }),
+    );
+    const scoreBody = (await scoreResponse.json()) as {
+      scoringRun: { id: string; composite_score: number };
+    };
+
+    expect(scoreResponse.status).toBe(201);
+    expect(scoreBody.scoringRun.composite_score).toBeGreaterThan(0);
+
+    const publicationResponse = await createPublication(
+      request({
+        platform: "official_site",
+        url: "https://example.com/article",
+        published_at: "2026-06-24T12:00:00.000Z",
+        notes: "官网首发",
+      }),
+      params<{ jobId: string }>({ jobId: job.id }),
+    );
+    const publicationBody = (await publicationResponse.json()) as {
+      publication: { id: string; notes: string };
+    };
+
+    expect(publicationResponse.status).toBe(201);
+    expect(publicationBody.publication.notes).toBe("官网首发");
+
+    const listResponse = await listPublications(
+      request({}),
+      params<{ jobId: string }>({ jobId: job.id }),
+    );
+    const listBody = (await listResponse.json()) as {
+      publications: Array<{ id: string }>;
+    };
+
+    expect(listResponse.status).toBe(200);
+    expect(listBody.publications).toHaveLength(1);
+
+    const performanceResponse = await recordPerformance(
+      request({
+        window_label: "T+7d",
+        views: "1200",
+        inquiries: "7",
+        feedback_summary: "用户追问案例依据",
+      }),
+      params<{ publicationId: string }>({
+        publicationId: publicationBody.publication.id,
+      }),
+    );
+    const performanceBody = (await performanceResponse.json()) as {
+      snapshot: { metrics: { views: number } };
+      calibrationEvent: { observations: string[] };
+    };
+
+    expect(performanceResponse.status).toBe(201);
+    expect(performanceBody.snapshot.metrics.views).toBe(1200);
+    expect(performanceBody.calibrationEvent.observations.length).toBeGreaterThan(0);
+  });
+
   it("returns backend-visible optimization progress after a job runs", async () => {
     const { job } = await createJobFixture();
     await confirmFactCard(

src/app/api/jobs/[jobId]/calibration/score/route.ts

@@ -0,0 +1,37 @@
+import { NextResponse } from "next/server";
+
+import { requireApiAccess } from "../../../../../../lib/api/auth";
+import {
+  GEO_RUBRIC_V1,
+  scoreOptimizedArticle,
+} from "../../../../../../lib/calibration/scoring";
+import { getRepositoryFromRuntime } from "../../../../../../lib/db/repository";
+
+interface RouteContext {
+  params: Promise<{ jobId: string }>;
+}
+
+export async function POST(request: Request, context: RouteContext) {
+  const access = requireApiAccess(request);
+  if (!access.ok) {
+    return access.response;
+  }
+
+  const { jobId } = await context.params;
+  const repository = getRepositoryFromRuntime();
+  const article = await repository.getLatestOptimizedArticle(jobId);
+  const qaReport = await repository.getLatestQaReport(jobId);
+  if (!article || !qaReport) {
+    return NextResponse.json(
+      { error: "Optimize the article before scoring calibration" },
+      { status: 409 },
+    );
+  }
+
+  await repository.saveRubricVersion(GEO_RUBRIC_V1);
+  const scoringRun = await repository.saveScoringRun(
+    scoreOptimizedArticle({ jobId, article, qaReport }),
+  );
+
+  return NextResponse.json({ scoringRun }, { status: 201 });
+}

src/app/api/jobs/[jobId]/publications/route.ts

@@ -0,0 +1,57 @@
+import { NextResponse } from "next/server";
+
+import { requireApiAccess } from "../../../../../lib/api/auth";
+import { publicationInputSchema } from "../../../../../lib/calibration/validation";
+import { getRepositoryFromRuntime } from "../../../../../lib/db/repository";
+
+interface RouteContext {
+  params: Promise<{ jobId: string }>;
+}
+
+export async function GET(request: Request, context: RouteContext) {
+  const access = requireApiAccess(request);
+  if (!access.ok) {
+    return access.response;
+  }
+
+  const { jobId } = await context.params;
+  const repository = getRepositoryFromRuntime();
+  return NextResponse.json({
+    publications: await repository.listPublicationRecords(jobId),
+  });
+}
+
+export async function POST(request: Request, context: RouteContext) {
+  const access = requireApiAccess(request);
+  if (!access.ok) {
+    return access.response;
+  }
+
+  const { jobId } = await context.params;
+  const repository = getRepositoryFromRuntime();
+  const article = await repository.getLatestOptimizedArticle(jobId);
+  if (!article?.revision) {
+    return NextResponse.json(
+      { error: "Optimize the article before registering publication" },
+      { status: 409 },
+    );
+  }
+
+  try {
+    const input = publicationInputSchema.parse(await request.json());
+    const publication = await repository.createPublicationRecord({
+      job_id: jobId,
+      revision: article.revision,
+      platform: input.platform,
+      url: input.url,
+      published_at: input.published_at,
+      status: "published",
+      notes: input.notes,
+    });
+
+    return NextResponse.json({ publication }, { status: 201 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid publication";
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}

src/app/api/publications/[publicationId]/performance/route.ts

@@ -0,0 +1,55 @@
+import { NextResponse } from "next/server";
+
+import { requireApiAccess } from "../../../../../lib/api/auth";
+import { createManualPerformanceAdapter } from "../../../../../lib/calibration/manual-adapter";
+import { createCalibrationEvent } from "../../../../../lib/calibration/scoring";
+import { getRepositoryFromRuntime } from "../../../../../lib/db/repository";
+
+interface RouteContext {
+  params: Promise<{ publicationId: string }>;
+}
+
+export async function POST(request: Request, context: RouteContext) {
+  const access = requireApiAccess(request);
+  if (!access.ok) {
+    return access.response;
+  }
+
+  const { publicationId } = await context.params;
+  const repository = getRepositoryFromRuntime();
+  const publication = await repository.getPublicationRecord(publicationId);
+  if (!publication) {
+    return NextResponse.json({ error: "Publication not found" }, { status: 404 });
+  }
+
+  const scoringRun = await repository.getLatestScoringRun(
+    publication.job_id,
+    publication.revision,
+  );
+  const qaReport = await repository.getLatestQaReport(publication.job_id);
+  if (!scoringRun || !qaReport) {
+    return NextResponse.json(
+      { error: "Score the optimized revision before recording performance" },
+      { status: 409 },
+    );
+  }
+
+  try {
+    const adapter = createManualPerformanceAdapter();
+    const snapshot = await repository.savePerformanceSnapshot(
+      await adapter.fetch({
+        publication,
+        window_label: "manual",
+        manualInput: await request.json(),
+      }),
+    );
+    const calibrationEvent = await repository.saveCalibrationEvent(
+      createCalibrationEvent({ scoringRun, qaReport, snapshot }),
+    );
+
+    return NextResponse.json({ snapshot, calibrationEvent }, { status: 201 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid performance";
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+}