agentic-orchestrator 0.1.28 → 0.2.0

package/packages/web-dashboard/src/app/api/features/[id]/conflicts/resolve/route.ts

@@ -0,0 +1,51 @@
+import { callOrchestratorTool } from '@/lib/orchestrator-tools.js';
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+
+export const dynamic = 'force-dynamic';
+
+interface ResolveRequest {
+  resolutions: Array<{
+    path: string;
+    strategy: 'accept_ours' | 'accept_theirs' | 'manual';
+    content?: string | null;
+  }>;
+}
+
+export async function POST(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const body = (await req.json()) as ResolveRequest;
+
+  if (!Array.isArray(body.resolutions) || body.resolutions.length === 0) {
+    return Response.json(
+      {
+        ok: false,
+        error: {
+          code: 'invalid_input',
+          message: 'resolutions array is required and must not be empty',
+        },
+      },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const response = await callOrchestratorTool(
+      'repo.resolve_conflict',
+      { feature_id: id, resolutions: body.resolutions },
+      { mutating: true, featureId: id, repoRoot },
+    );
+
+    return Response.json(response, { status: response.ok ? 200 : 409 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to resolve conflicts';
+    return Response.json(
+      { ok: false, error: { code: 'conflict_resolve_failed', message } },
+      { status: 500 },
+    );
+  }
+}

package/packages/web-dashboard/src/app/api/features/[id]/conflicts/route.ts

@@ -0,0 +1,75 @@
+import { callOrchestratorTool } from '@/lib/orchestrator-tools.js';
+import { readFeatureState, resolveProjectRoot } from '@/lib/aop-client.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+
+  try {
+    const feature = await readFeatureState(id, repoRoot);
+    if (!feature) {
+      return Response.json(
+        { ok: false, error: { code: 'feature_not_found', message: `Feature ${id} not found` } },
+        { status: 404 },
+      );
+    }
+
+    const stateResponse = await callOrchestratorTool(
+      'feature.state_get',
+      { feature_id: id },
+      { repoRoot },
+    );
+
+    if (!stateResponse.ok || !stateResponse.data) {
+      return Response.json(stateResponse, { status: 409 });
+    }
+
+    const frontMatter = (stateResponse.data as Record<string, unknown>).front_matter as
+      | Record<string, unknown>
+      | undefined;
+    const conflicts = Array.isArray(frontMatter?.conflicts) ? frontMatter.conflicts : [];
+    const mainlineConflict = conflicts.find(
+      (entry: unknown) =>
+        entry &&
+        typeof entry === 'object' &&
+        (entry as Record<string, unknown>).type === 'mainline_divergence',
+    ) as Record<string, unknown> | undefined;
+
+    if (!mainlineConflict) {
+      return Response.json({
+        ok: true,
+        data: null,
+      });
+    }
+
+    return Response.json({
+      ok: true,
+      data: {
+        type: 'mainline_divergence',
+        merge_base: mainlineConflict.merge_base ?? null,
+        mainline_head: mainlineConflict.mainline_head ?? null,
+        worktree_head: mainlineConflict.worktree_head ?? null,
+        conflicting_files: Array.isArray(mainlineConflict.conflicting_files)
+          ? mainlineConflict.conflicting_files
+          : [],
+        resolution_status: mainlineConflict.resolution_status ?? 'pending',
+        detected_at: mainlineConflict.detected_at ?? null,
+        queue_position: mainlineConflict.queue_position ?? null,
+        reconciler_active: mainlineConflict.resolution_status === 'in_progress',
+        reconciler_active_feature_id: mainlineConflict.reconciler_active_feature_id ?? null,
+      },
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to read conflict summary';
+    return Response.json(
+      { ok: false, error: { code: 'conflict_read_failed', message } },
+      { status: 500 },
+    );
+  }
+}

package/packages/web-dashboard/src/app/api/features/[id]/diff/route.ts

@@ -1,4 +1,6 @@
-import { readFeatureDiff, resolveProjectRoot } from '@/lib/aop-client.js';
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+import { FEATURE_ID_PATTERN } from '@/lib/review-contracts.js';
+import { readLiveFeatureDiff } from '@/lib/worktree-diff.js';
 
 export const dynamic = 'force-dynamic';
 
@@ -7,8 +9,20 @@ export async function GET(
   { params }: { params: Promise<{ id: string }> },
 ): Promise<Response> {
   const { id } = await params;
+  if (!FEATURE_ID_PATTERN.test(id)) {
+    return new Response('Invalid feature id', {
+      status: 400,
+      headers: { 'Content-Type': 'text/plain' },
+    });
+  }
   const project = new URL(req.url).searchParams.get('project');
   const repoRoot = await resolveProjectRoot(project);
-  const diff = await readFeatureDiff(id, repoRoot);
+  const diff = await readLiveFeatureDiff(id, repoRoot);
+  if (diff == null) {
+    return new Response(`Feature ${id} not found`, {
+      status: 404,
+      headers: { 'Content-Type': 'text/plain' },
+    });
+  }
   return new Response(diff, { headers: { 'Content-Type': 'text/plain' } });
 }

package/packages/web-dashboard/src/app/api/features/[id]/files/route.ts

@@ -0,0 +1,26 @@
+import { readFeatureFiles, resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+import { FEATURE_ID_PATTERN } from '@/lib/review-contracts.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  if (!FEATURE_ID_PATTERN.test(id)) {
+    return Response.json(errorEnvelope('invalid_input', 'Invalid feature id'), { status: 400 });
+  }
+
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const files = await readFeatureFiles(id, repoRoot);
+  if (!files) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${id} not found`), {
+      status: 404,
+    });
+  }
+
+  return Response.json(okEnvelope(files, { source: 'artifact' }));
+}

package/packages/web-dashboard/src/app/api/features/[id]/gate-history/route.ts

@@ -0,0 +1,27 @@
+import { readFeatureState, readGateHistory, resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+import { FEATURE_ID_PATTERN } from '@/lib/review-contracts.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  if (!FEATURE_ID_PATTERN.test(id)) {
+    return Response.json(errorEnvelope('invalid_input', 'Invalid feature id'), { status: 400 });
+  }
+
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const feature = await readFeatureState(id, repoRoot);
+  if (!feature) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${id} not found`), {
+      status: 404,
+    });
+  }
+
+  const history = await readGateHistory(id, repoRoot);
+  return Response.json(okEnvelope({ feature_id: id, history }, { source: 'artifact' }));
+}

package/packages/web-dashboard/src/app/api/features/[id]/genealogy/route.ts

@@ -0,0 +1,26 @@
+import { readFeatureGenealogy, resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+import { FEATURE_ID_PATTERN } from '@/lib/review-contracts.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  if (!FEATURE_ID_PATTERN.test(id)) {
+    return Response.json(errorEnvelope('invalid_input', 'Invalid feature id'), { status: 400 });
+  }
+
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const genealogy = await readFeatureGenealogy(id, repoRoot);
+  if (!genealogy) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${id} not found`), {
+      status: 404,
+    });
+  }
+
+  return Response.json(okEnvelope(genealogy, { source: 'artifact' }));
+}

package/packages/web-dashboard/src/app/api/features/[id]/history/run/[runId]/route.ts

@@ -0,0 +1,20 @@
+import { readFeatureRunHistoryDetail, resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string; runId: string }> },
+): Promise<Response> {
+  const { id, runId } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const detail = await readFeatureRunHistoryDetail(id, runId, repoRoot);
+  if (!detail) {
+    return Response.json(errorEnvelope('artifact_missing', `Run ${runId} was not found`), {
+      status: 404,
+    });
+  }
+  return Response.json(okEnvelope(detail, { source: 'artifact' }));
+}

package/packages/web-dashboard/src/app/api/features/[id]/history/runs/route.ts

@@ -0,0 +1,34 @@
+import { readFeatureRunHistory, resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const runs = await readFeatureRunHistory(id, repoRoot);
+  if (runs.length === 0) {
+    return Response.json(
+      okEnvelope(
+        {
+          feature_id: id,
+          runs: [],
+        },
+        { source: 'artifact' },
+      ),
+    );
+  }
+  return Response.json(
+    okEnvelope(
+      {
+        feature_id: id,
+        runs,
+      },
+      { source: 'artifact' },
+    ),
+  );
+}

package/packages/web-dashboard/src/app/api/features/[id]/intake-workspace/route.ts

@@ -0,0 +1,20 @@
+import { readFeatureIntakeWorkspace, resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const workspace = await readFeatureIntakeWorkspace(id, repoRoot);
+  if (!workspace) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${id} not found`), {
+      status: 404,
+    });
+  }
+  return Response.json(okEnvelope(workspace, { source: 'artifact' }));
+}

package/packages/web-dashboard/src/app/api/features/[id]/live-output/route.ts

@@ -0,0 +1,74 @@
+import {
+  DEFAULT_LIVE_AGENT_OUTPUT_LINE_LIMIT,
+  readFeatureState,
+  readLiveAgentOutputSnapshots,
+  resolveProjectRoot,
+} from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+import { readPolicyYaml } from '@/lib/policy-reader.js';
+import { FEATURE_ID_PATTERN } from '@/lib/review-contracts.js';
+
+export const dynamic = 'force-dynamic';
+const MAX_LIVE_AGENT_OUTPUT_LINE_LIMIT = 5_000;
+
+function isRawLogsEnabled(policy: Record<string, unknown> | null): boolean {
+  if (!policy || typeof policy !== 'object') {
+    return false;
+  }
+  const observability = policy.observability;
+  if (!observability || typeof observability !== 'object') {
+    return false;
+  }
+  return (observability as Record<string, unknown>).raw_agent_logs_enabled === true;
+}
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  if (!FEATURE_ID_PATTERN.test(id)) {
+    return Response.json(errorEnvelope('invalid_input', 'Invalid feature id'), { status: 400 });
+  }
+
+  const searchParams = new URL(req.url).searchParams;
+  const project = searchParams.get('project');
+  const requestedLineLimit = Number.parseInt(searchParams.get('line_limit') ?? '', 10);
+  const lineLimit =
+    Number.isFinite(requestedLineLimit) && requestedLineLimit > 0
+      ? Math.min(requestedLineLimit, MAX_LIVE_AGENT_OUTPUT_LINE_LIMIT)
+      : DEFAULT_LIVE_AGENT_OUTPUT_LINE_LIMIT;
+  const repoRoot = await resolveProjectRoot(project);
+  const state = await readFeatureState(id, repoRoot);
+  if (!state) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${id} not found`), {
+      status: 404,
+    });
+  }
+
+  const policy = await readPolicyYaml(repoRoot);
+  if (!isRawLogsEnabled(policy)) {
+    return Response.json(
+      okEnvelope(
+        {
+          enabled: false,
+          line_limit: lineLimit,
+          snapshots: [],
+        },
+        { source: 'artifact' },
+      ),
+    );
+  }
+
+  const snapshots = await readLiveAgentOutputSnapshots(id, repoRoot, { tailLines: lineLimit });
+  return Response.json(
+    okEnvelope(
+      {
+        enabled: true,
+        line_limit: lineLimit,
+        snapshots,
+      },
+      { source: 'artifact' },
+    ),
+  );
+}

package/packages/web-dashboard/src/app/api/features/[id]/plan/amend/route.ts

@@ -0,0 +1,21 @@
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+import { amendFeaturePlan } from '@/lib/orchestrator-tools.js';
+
+export const dynamic = 'force-dynamic';
+
+interface PlanAmendRequest {
+  plan_json: string | Record<string, unknown>;
+  revision_reason?: string;
+}
+
+export async function POST(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const body = (await req.json()) as PlanAmendRequest;
+  const response = await amendFeaturePlan(id, body.plan_json, body.revision_reason ?? '', repoRoot);
+  return Response.json(response, { status: response.ok ? 200 : 409 });
+}

package/packages/web-dashboard/src/app/api/features/[id]/plan-progress/route.ts

@@ -0,0 +1,20 @@
+import { readFeaturePlanProgress, resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const progress = await readFeaturePlanProgress(id, repoRoot);
+  if (!progress) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${id} not found`), {
+      status: 404,
+    });
+  }
+  return Response.json(okEnvelope(progress, { source: 'artifact' }));
+}

package/packages/web-dashboard/src/app/api/features/[id]/planner-artifacts/[artifact]/route.ts

@@ -0,0 +1,78 @@
+import { readPlannerArtifactRaw, resolveProjectRoot } from '@/lib/aop-client.js';
+import type { PlannerArtifactId } from '@/lib/aop-client.js';
+
+export const dynamic = 'force-dynamic';
+
+const ALLOWED_ARTIFACTS = new Set([
+  'source_spec',
+  'bootstrap_manifest',
+  'verified_manifest',
+  'intake_review',
+  'plan_markdown',
+  'plan_json',
+]);
+
+function contentType(artifact: string): string {
+  if (
+    artifact === 'bootstrap_manifest' ||
+    artifact === 'verified_manifest' ||
+    artifact === 'intake_review' ||
+    artifact === 'plan_json'
+  ) {
+    return 'application/json';
+  }
+  return 'text/plain; charset=utf-8';
+}
+
+function filename(artifact: string): string {
+  if (artifact === 'source_spec') {
+    return 'spec.md';
+  }
+  if (artifact === 'bootstrap_manifest') {
+    return 'spec.manifest.bootstrap.json';
+  }
+  if (artifact === 'verified_manifest') {
+    return 'spec.manifest.verified.json';
+  }
+  if (artifact === 'intake_review') {
+    return 'intake.review.json';
+  }
+  if (artifact === 'plan_markdown') {
+    return 'plan.md';
+  }
+  return 'plan.json';
+}
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string; artifact: string }> },
+): Promise<Response> {
+  const { id, artifact } = await params;
+  if (!ALLOWED_ARTIFACTS.has(artifact)) {
+    return Response.json(
+      {
+        ok: false,
+        error: { code: 'artifact_not_found', message: `Artifact not found: ${artifact}` },
+      },
+      { status: 404 },
+    );
+  }
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const raw = await readPlannerArtifactRaw(id, artifact as PlannerArtifactId, repoRoot);
+  if (!raw) {
+    return Response.json(
+      {
+        ok: false,
+        error: { code: 'artifact_not_found', message: `Artifact not found: ${artifact}` },
+      },
+      { status: 404 },
+    );
+  }
+  return new Response(raw.content, {
+    headers: {
+      'Content-Type': contentType(artifact),
+      'Content-Disposition': `inline; filename="${filename(artifact)}"`,
+    },
+  });
+}

package/packages/web-dashboard/src/app/api/features/[id]/planner-lifecycle/route.ts

@@ -0,0 +1,20 @@
+import { readPlannerLifecycle, resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const lifecycle = await readPlannerLifecycle(id, repoRoot);
+  if (!lifecycle) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${id} not found`), {
+      status: 404,
+    });
+  }
+  return Response.json(okEnvelope(lifecycle, { source: 'artifact' }));
+}

package/packages/web-dashboard/src/app/api/features/[id]/planning-workspace/route.ts

@@ -0,0 +1,20 @@
+import { readFeaturePlanningWorkspace, resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const workspace = await readFeaturePlanningWorkspace(id, repoRoot);
+  if (!workspace) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${id} not found`), {
+      status: 404,
+    });
+  }
+  return Response.json(okEnvelope(workspace, { source: 'artifact' }));
+}

package/packages/web-dashboard/src/app/api/features/[id]/questions/[questionId]/answer/route.ts

@@ -0,0 +1,27 @@
+import { answerFeatureQuestion } from '@/lib/orchestrator-tools.js';
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+
+export const dynamic = 'force-dynamic';
+
+interface AnswerRequest {
+  answer: string | Record<string, unknown>;
+  answered_by?: string;
+}
+
+export async function POST(
+  req: Request,
+  { params }: { params: Promise<{ id: string; questionId: string }> },
+): Promise<Response> {
+  const { id, questionId } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const body = (await req.json()) as AnswerRequest;
+  const response = await answerFeatureQuestion(
+    id,
+    questionId,
+    body.answer,
+    body.answered_by ?? 'dashboard',
+    repoRoot,
+  );
+  return Response.json(response, { status: response.ok ? 200 : 409 });
+}

package/packages/web-dashboard/src/app/api/features/[id]/questions/route.ts

@@ -0,0 +1,18 @@
+import { readFeatureQuestions, resolveProjectRoot } from '@/lib/aop-client.js';
+import { okEnvelope } from '@/lib/api-envelope.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(
+  req: Request,
+  { params }: { params: Promise<{ id: string }> },
+): Promise<Response> {
+  const { id } = await params;
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const items = await readFeatureQuestions(id, repoRoot);
+  if (items.length === 0) {
+    return Response.json(okEnvelope({ items: [] }, { source: 'artifact' }));
+  }
+  return Response.json(okEnvelope({ items }, { source: 'artifact' }));
+}

package/packages/web-dashboard/src/app/api/features/[id]/review/route.ts

@@ -1,14 +1,15 @@
 import {
-  approveFeatureReview,
+  approveFeatureReviewAsync,
   denyFeatureReview,
   requestFeatureChanges,
+  runFeatureMergeGate,
 } from '@/lib/orchestrator-tools.js';
 import { resolveProjectRoot } from '@/lib/aop-client.js';
 
 export const dynamic = 'force-dynamic';
 
 interface ReviewRequest {
-  decision: 'approve' | 'deny' | 'request_changes';
+  decision: 'approve' | 'deny' | 'request_changes' | 'run_merge_gate';
   approval_token?: string;
   merge_strategy?: 'merge_commit' | 'squash' | 'rebase';
   commit_message?: string;
@@ -25,19 +26,24 @@ export async function POST(
   const repoRoot = await resolveProjectRoot(project);
   const body = (await req.json()) as ReviewRequest;
 
-  if (!['approve', 'deny', 'request_changes'].includes(body.decision)) {
+  if (!['approve', 'deny', 'request_changes', 'run_merge_gate'].includes(body.decision)) {
     return Response.json(
       {
         ok: false,
         error: {
           code: 'invalid_decision',
-          message: 'decision must be approve, deny, or request_changes',
+          message: 'decision must be approve, deny, request_changes, or run_merge_gate',
         },
       },
       { status: 400 },
     );
   }
 
+  if (body.decision === 'run_merge_gate') {
+    const response = await runFeatureMergeGate(id, repoRoot, { force: true });
+    return Response.json(response, { status: response.ok ? 200 : 409 });
+  }
+
   if (body.decision === 'approve') {
     if (!body.approval_token || body.approval_token.trim().length === 0) {
       return Response.json(
@@ -51,15 +57,16 @@ export async function POST(
         { status: 400 },
       );
     }
+    const commitMessage = body.commit_message ?? body.message;
 
-    const response = await approveFeatureReview(
+    const response = await approveFeatureReviewAsync(
       id,
       body.approval_token.trim(),
       body.merge_strategy ?? 'merge_commit',
-      body.commit_message,
+      commitMessage,
       repoRoot,
     );
-    return Response.json(response, { status: response.ok ? 200 : 409 });
+    return Response.json(response, { status: response.ok ? 202 : 409 });
   }
 
   if (body.decision === 'deny') {