agentic-orchestrator 0.1.28 → 0.2.0

package/packages/web-dashboard/src/app/api/actions/route.ts

@@ -1,34 +1,41 @@
+import { authorizeDashboardAction } from '@/lib/authz-adapter.js';
 import {
-  approveFeatureReview,
+  approveFeatureReviewAsync,
   denyFeatureReview,
+  resumeFeatureExecution,
   requestFeatureChanges,
   retryFeature,
+  runFeatureMergeGate,
   sendFeatureMessage,
 } from '@/lib/orchestrator-tools.js';
+import { isDashboardRuntimeAvailable } from '@/lib/dashboard-runtime-client.js';
+import {
+  actionState,
+  computeDashboardFeatureActionStates,
+  type DashboardFeatureActionStates,
+  type RuntimeSessionSnapshot,
+} from '@/lib/dashboard-action-states.js';
 import { readFeaturesIndex, readFeatureState, resolveProjectRoot } from '@/lib/aop-client.js';
 import { TERMINAL_FEATURE_STATUSES } from '@/lib/review-contracts.js';
+import type {
+  DashboardActionState,
+  DashboardFeatureActionKey,
+  FeatureSummary,
+} from '@/lib/types.js';
 
 export const dynamic = 'force-dynamic';
 const SEND_MESSAGE_MIN_INTERVAL_MS = 1_000;
 const sendMessageTimestamps = new Map<string, number>();
 
-function hasActiveSessionId(value: unknown): boolean {
-  return (
-    typeof value === 'string' &&
-    value.length > 0 &&
-    value !== 'unknown' &&
-    value !== 'unassigned' &&
-    value !== 'none'
-  );
-}
-
 interface ActionsRequest {
   action:
+    | 'review.run_merge_gate'
     | 'review.approve'
     | 'review.deny'
     | 'review.request_changes'
     | 'feature.send_message'
-    | 'feature.retry';
+    | 'feature.retry'
+    | 'feature.resume';
   feature_id: string;
   approval_token?: string;
   reason?: string;
@@ -37,6 +44,124 @@ interface ActionsRequest {
   commit_message?: string;
 }
 
+type ActionStateMap = DashboardFeatureActionStates;
+
+async function authorizeAction(
+  req: Request,
+  project: string | null,
+  action: string,
+): Promise<{ authorized: boolean; reason: string | null }> {
+  const auth = await authorizeDashboardAction({ action, project, request: req });
+  return {
+    authorized: auth.allowed,
+    reason: auth.allowed ? null : (auth.message ?? 'Action not authorized'),
+  };
+}
+
+async function computeActionStates(
+  req: Request,
+  project: string | null,
+  repoRoot: string,
+  featureId: string,
+): Promise<{
+  feature: FeatureSummary | null;
+  states: ActionStateMap;
+  runtimeSessions: RuntimeSessionSnapshot | null;
+}> {
+  const [
+    feature,
+    index,
+    dashboardRuntimeAvailable,
+    approveAuth,
+    denyAuth,
+    requestAuth,
+    retryAuth,
+    resumeAuth,
+    sendAuth,
+  ] = await Promise.all([
+    readFeatureState(featureId, repoRoot),
+    readFeaturesIndex(repoRoot),
+    isDashboardRuntimeAvailable(repoRoot),
+    authorizeAction(req, project, 'dashboard.review.approve'),
+    authorizeAction(req, project, 'dashboard.review.deny'),
+    authorizeAction(req, project, 'dashboard.review.request_changes'),
+    authorizeAction(req, project, 'dashboard.feature.retry'),
+    authorizeAction(req, project, 'dashboard.feature.resume'),
+    authorizeAction(req, project, 'dashboard.feature.send_message'),
+  ]);
+
+  const states = computeDashboardFeatureActionStates({
+    feature,
+    runtimeSessions: index.runtime_sessions ?? null,
+    dashboardRuntimeAvailable,
+    authorizations: {
+      approve: approveAuth,
+      deny: denyAuth,
+      requestChanges: requestAuth,
+      retry: retryAuth,
+      resume: resumeAuth,
+      sendMessage: sendAuth,
+    },
+  });
+
+  return {
+    feature,
+    runtimeSessions: index.runtime_sessions ?? null,
+    states,
+  };
+}
+
+function actionKeyForRequest(action: ActionsRequest['action']): DashboardFeatureActionKey {
+  if (action === 'review.run_merge_gate') {
+    return 'run_merge_gate';
+  }
+  if (action === 'review.approve') {
+    return 'approve';
+  }
+  if (action === 'review.deny') {
+    return 'deny';
+  }
+  if (action === 'review.request_changes') {
+    return 'request_changes';
+  }
+  if (action === 'feature.retry') {
+    return 'retry';
+  }
+  if (action === 'feature.resume') {
+    return 'resume';
+  }
+  return 'send_message';
+}
+
+function disabledResponse(state: DashboardActionState, status = 409): Response {
+  return Response.json(
+    {
+      ok: false,
+      error: {
+        code: state.authorized ? 'action_disabled' : 'unauthorized_action',
+        message: state.reason ?? 'Action unavailable',
+      },
+      action_state: state,
+    },
+    { status: state.authorized ? status : 403 },
+  );
+}
+
+function canInvokeRetryDirectly(
+  action: ActionsRequest['action'],
+  feature: FeatureSummary | null,
+  state: DashboardActionState | undefined,
+): boolean {
+  return (
+    action === 'feature.retry' &&
+    feature != null &&
+    !TERMINAL_FEATURE_STATUSES.has(feature.status) &&
+    feature.status !== 'awaiting_input' &&
+    feature.phase !== 'awaiting_input' &&
+    state?.authorized === true
+  );
+}
+
 export async function POST(req: Request): Promise<Response> {
   const project = new URL(req.url).searchParams.get('project');
   const repoRoot = await resolveProjectRoot(project);
@@ -48,6 +173,43 @@ export async function POST(req: Request): Promise<Response> {
     );
   }
 
+  const { feature, states } = await computeActionStates(req, project, repoRoot, body.feature_id);
+  const requestedState = states[actionKeyForRequest(body.action)];
+  if (!feature) {
+    return Response.json(
+      {
+        ok: false,
+        error: { code: 'feature_not_found', message: `Feature ${body.feature_id} not found` },
+        action_state: requestedState,
+      },
+      { status: 404 },
+    );
+  }
+  if (
+    body.action === 'feature.send_message' &&
+    requestedState?.authorized &&
+    !requestedState.enabled
+  ) {
+    return Response.json(
+      {
+        ok: false,
+        error: {
+          code: 'session_inactive',
+          message: requestedState.reason ?? 'No active runtime session is available',
+        },
+        action_state: requestedState,
+      },
+      { status: 409 },
+    );
+  }
+  const retryCompatibilityMode = canInvokeRetryDirectly(body.action, feature, requestedState);
+  const responseActionState = retryCompatibilityMode
+    ? actionState(true, true, null)
+    : requestedState;
+  if (!retryCompatibilityMode && (!requestedState?.authorized || !requestedState.enabled)) {
+    return disabledResponse(requestedState ?? actionState(false, false, 'Action unavailable'));
+  }
+
   if (body.action === 'review.approve') {
     if (!body.approval_token) {
       return Response.json(
@@ -61,14 +223,27 @@ export async function POST(req: Request): Promise<Response> {
         { status: 400 },
       );
     }
-    const response = await approveFeatureReview(
+    const commitMessage = body.commit_message ?? body.message;
+    const response = await approveFeatureReviewAsync(
       body.feature_id,
       body.approval_token,
       body.merge_strategy ?? 'merge_commit',
-      body.commit_message,
+      commitMessage,
       repoRoot,
     );
-    return Response.json(response, { status: response.ok ? 200 : 409 });
+    if (!response.ok) {
+      return Response.json({ ...response, action_state: requestedState }, { status: 409 });
+    }
+    // Return 202 Accepted with request_id for polling
+    return Response.json({ ...response, action_state: requestedState }, { status: 202 });
+  }
+
+  if (body.action === 'review.run_merge_gate') {
+    const response = await runFeatureMergeGate(body.feature_id, repoRoot, { force: true });
+    return Response.json(
+      { ...response, action_state: requestedState },
+      { status: response.ok ? 200 : 409 },
+    );
   }
 
   if (body.action === 'review.deny') {
@@ -82,12 +257,18 @@ export async function POST(req: Request): Promise<Response> {
       );
     }
     const response = await denyFeatureReview(body.feature_id, body.reason.trim(), repoRoot);
-    return Response.json(response, { status: response.ok ? 200 : 409 });
+    return Response.json(
+      { ...response, action_state: requestedState },
+      { status: response.ok ? 200 : 409 },
+    );
   }
 
   if (body.action === 'review.request_changes') {
     const response = await requestFeatureChanges(body.feature_id, body.message ?? '', repoRoot);
-    return Response.json(response, { status: response.ok ? 200 : 409 });
+    return Response.json(
+      { ...response, action_state: requestedState },
+      { status: response.ok ? 200 : 409 },
+    );
   }
 
   if (body.action === 'feature.send_message') {
@@ -104,90 +285,120 @@ export async function POST(req: Request): Promise<Response> {
       );
     }
 
-    const state = await readFeatureState(body.feature_id, repoRoot);
-    if (!state) {
-      return Response.json(
-        {
-          ok: false,
-          error: { code: 'feature_not_found', message: `Feature ${body.feature_id} not found` },
-        },
-        { status: 404 },
-      );
-    }
-    if (TERMINAL_FEATURE_STATUSES.has(state.status)) {
+    const throttleKey = `${repoRoot}:${body.feature_id}`;
+    const lastSentAt = sendMessageTimestamps.get(throttleKey) ?? 0;
+    const now = Date.now();
+    if (now - lastSentAt < SEND_MESSAGE_MIN_INTERVAL_MS) {
       return Response.json(
         {
           ok: false,
           error: {
-            code: 'session_inactive',
-            message: `Feature ${body.feature_id} is terminal (${state.status}) and cannot receive messages`,
+            code: 'invalid_input',
+            message: 'Please wait at least 1 second before sending another message',
           },
+          action_state: requestedState,
         },
-        { status: 409 },
+        { status: 429 },
       );
     }
 
-    const index = await readFeaturesIndex(repoRoot);
-    const runId = index.runtime_sessions?.run_id;
-    const cluster = state.cluster;
-    const hasClusterSession =
-      cluster &&
-      (hasActiveSessionId(cluster.orchestrator_session_id) ||
-        hasActiveSessionId(cluster.planner_session_id) ||
-        hasActiveSessionId(cluster.builder_session_id) ||
-        hasActiveSessionId(cluster.qa_session_id));
-    if (!hasActiveSessionId(runId) || !hasClusterSession) {
+    const response = await sendFeatureMessage(body.feature_id, body.message.trim(), repoRoot);
+    if (response.ok) {
+      sendMessageTimestamps.set(throttleKey, now);
+      return Response.json({ ...response, action_state: requestedState }, { status: 200 });
+    }
+    if (response.error?.code === 'session_not_found') {
       return Response.json(
         {
           ok: false,
           error: {
             code: 'session_inactive',
-            message: `No active runtime session is available for feature ${body.feature_id}`,
+            message: 'No active runtime session is available for this feature',
           },
+          action_state: requestedState,
         },
         { status: 409 },
       );
     }
+    return Response.json(
+      { ...response, action_state: requestedState },
+      { status: response.ok ? 200 : 409 },
+    );
+  }
 
-    const throttleKey = `${repoRoot}:${body.feature_id}`;
-    const lastSentAt = sendMessageTimestamps.get(throttleKey) ?? 0;
-    const now = Date.now();
-    if (now - lastSentAt < SEND_MESSAGE_MIN_INTERVAL_MS) {
+  if (body.action === 'feature.retry') {
+    const response = await retryFeature(body.feature_id, repoRoot);
+    if (!response.ok) {
+      return Response.json({ ...response, action_state: responseActionState }, { status: 409 });
+    }
+
+    // Use the same auto-resume decision logic as CLI:
+    // attempt resume when retry produced a reroute_status (state patch) but did not execute gates in-place
+    const retryData = (response.data ?? {}) as Record<string, unknown>;
+    const hasRerouteStatus =
+      typeof retryData.reroute_status === 'string' && retryData.reroute_status.length > 0;
+    const retryExecutedInPlace = retryData.retry_executed === true;
+    const waitingForInput = retryData.waiting_for_input === true;
+    const shouldAutoResume = waitingForInput || (hasRerouteStatus && !retryExecutedInPlace);
+
+    if (!shouldAutoResume) {
       return Response.json(
         {
-          ok: false,
-          error: {
-            code: 'invalid_input',
-            message: 'Please wait at least 1 second before sending another message',
+          ok: true,
+          data: {
+            retry: retryData,
+            auto_resume: {
+              attempted: false,
+              skipped_reason: retryExecutedInPlace
+                ? 'retry_completed_in_place'
+                : 'no_resume_required',
+            },
           },
+          action_state: responseActionState,
         },
-        { status: 429 },
+        { status: 200 },
       );
     }
 
-    const response = await sendFeatureMessage(body.feature_id, body.message.trim(), repoRoot);
-    if (response.ok) {
-      sendMessageTimestamps.set(throttleKey, now);
-      return Response.json(response, { status: 200 });
-    }
-    if (response.error?.code === 'session_not_found') {
+    const autoResumeResponse = await resumeFeatureExecution(body.feature_id, repoRoot);
+    if (!autoResumeResponse.ok) {
       return Response.json(
         {
           ok: false,
           error: {
-            code: 'session_inactive',
-            message: 'No active runtime session is available for this feature',
+            code: autoResumeResponse.error?.code ?? 'retry_recovery_failed',
+            message:
+              autoResumeResponse.error?.message ??
+              'Retry completed, but execution could not be resumed',
+            details: {
+              retry: retryData,
+              auto_resume: autoResumeResponse.error?.details ?? null,
+            },
           },
+          action_state: responseActionState,
         },
         { status: 409 },
       );
     }
-    return Response.json(response, { status: response.ok ? 200 : 409 });
+    return Response.json(
+      {
+        ok: true,
+        data: {
+          retry: retryData,
+          auto_resume: autoResumeResponse.data ?? {},
+        },
+        action_state: responseActionState,
+      },
+      { status: 200 },
+    );
   }
 
-  if (body.action === 'feature.retry') {
-    const response = await retryFeature(body.feature_id, repoRoot);
-    return Response.json(response, { status: response.ok ? 200 : 409 });
+  if (body.action === 'feature.resume') {
+    const response = await resumeFeatureExecution(body.feature_id, repoRoot);
+    return Response.json(
+      { ...response, action_state: requestedState },
+      { status: response.ok ? 200 : 409 },
+    );
   }
 
   return Response.json(

package/packages/web-dashboard/src/app/api/actions/status/route.ts

@@ -0,0 +1,35 @@
+import { readCommandStatus } from '@/lib/dashboard-runtime-client.js';
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const requestId = url.searchParams.get('request_id');
+  const project = url.searchParams.get('project');
+
+  if (!requestId) {
+    return Response.json(
+      { ok: false, error: { code: 'invalid_input', message: 'request_id is required' } },
+      { status: 400 },
+    );
+  }
+
+  const repoRoot = await resolveProjectRoot(project);
+  const status = await readCommandStatus(repoRoot, requestId);
+
+  if (status.status === 'not_found') {
+    return Response.json(
+      {
+        ok: false,
+        error: {
+          code: 'command_not_found',
+          message: `No command found with request_id ${requestId}`,
+        },
+      },
+      { status: 404 },
+    );
+  }
+
+  return Response.json({ ok: true, data: status });
+}

package/packages/web-dashboard/src/app/api/analytics/provider/route.ts

@@ -0,0 +1,18 @@
+import { readProviderAnalyticsSnapshot, resolveProjectRoot } from '@/lib/aop-client.js';
+import { okEnvelope } from '@/lib/api-envelope.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(req: Request): Promise<Response> {
+  const project = new URL(req.url).searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const providers = await readProviderAnalyticsSnapshot(repoRoot);
+  return Response.json(
+    okEnvelope(
+      {
+        providers,
+      },
+      { source: 'derived' },
+    ),
+  );
+}

package/packages/web-dashboard/src/app/api/collisions/approve/route.ts

@@ -0,0 +1,58 @@
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+import { approveCollisionOverride } from '@/lib/orchestrator-tools.js';
+
+export const dynamic = 'force-dynamic';
+
+interface ApproveRequest {
+  feature_id: string;
+  with_feature_id: string;
+  reason: string;
+  resume?: boolean;
+}
+
+export async function POST(req: Request): Promise<Response> {
+  try {
+    const project = new URL(req.url).searchParams.get('project');
+    const repoRoot = await resolveProjectRoot(project);
+    const body = (await req.json()) as ApproveRequest;
+
+    if (!body.feature_id || !body.with_feature_id) {
+      return Response.json(
+        errorEnvelope('missing_fields', 'feature_id and with_feature_id are required'),
+        { status: 400 },
+      );
+    }
+
+    if (!body.reason || body.reason.trim().length === 0) {
+      return Response.json(
+        errorEnvelope('reason_required', 'A reason is required for collision approval'),
+        { status: 400 },
+      );
+    }
+
+    const result = await approveCollisionOverride(
+      body.feature_id,
+      body.with_feature_id,
+      body.reason.trim(),
+      body.resume ?? true,
+      repoRoot,
+    );
+
+    if (!result.ok) {
+      return Response.json(
+        errorEnvelope(
+          result.error?.code ?? 'collision_override_failed',
+          result.error?.message ?? 'Failed to approve collision override',
+        ),
+        { status: 409 },
+      );
+    }
+
+    return Response.json(okEnvelope(result.data ?? { approved: true }, { source: 'derived' }));
+  } catch {
+    return Response.json(errorEnvelope('internal_error', 'Unexpected error approving collision'), {
+      status: 500,
+    });
+  }
+}

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

@@ -0,0 +1,36 @@
+import { readFeatureCheckpointDiff, 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 url = new URL(req.url);
+  const checkpointId = url.searchParams.get('checkpoint_id')?.trim() ?? '';
+  if (!checkpointId) {
+    return Response.json(errorEnvelope('invalid_input', 'checkpoint_id is required'), {
+      status: 400,
+    });
+  }
+  const project = url.searchParams.get('project');
+  const repoRoot = await resolveProjectRoot(project);
+  const snapshot = await readFeatureCheckpointDiff(id, checkpointId, repoRoot);
+  if (!snapshot) {
+    return Response.json(
+      errorEnvelope('checkpoint_not_found', `Checkpoint ${checkpointId} not found`),
+      { status: 404 },
+    );
+  }
+  return Response.json(
+    okEnvelope(
+      {
+        checkpoint: snapshot.checkpoint,
+        diff: snapshot.diff,
+      },
+      { source: 'artifact' },
+    ),
+  );
+}

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

@@ -0,0 +1,29 @@
+import { readFeatureCheckpointsPage, 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 url = new URL(req.url);
+  const project = url.searchParams.get('project');
+  const cursor = url.searchParams.get('cursor');
+  const includeIdle = url.searchParams.get('include_idle') === '1';
+  const limitRaw = Number.parseInt(url.searchParams.get('limit') ?? '20', 10);
+  const limit = Number.isNaN(limitRaw) ? 20 : limitRaw;
+  const repoRoot = await resolveProjectRoot(project);
+  const page = await readFeatureCheckpointsPage(id, repoRoot, {
+    cursor,
+    limit,
+    includeIdle,
+  });
+  if (!page) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${id} not found`), {
+      status: 404,
+    });
+  }
+  return Response.json(okEnvelope(page, { source: 'artifact' }));
+}

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

@@ -0,0 +1,29 @@
+import { callOrchestratorTool } from '@/lib/orchestrator-tools.js';
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+
+export const dynamic = 'force-dynamic';
+
+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);
+
+  try {
+    const response = await callOrchestratorTool(
+      'repo.conflict_abort',
+      { feature_id: id },
+      { 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 abort conflict merge';
+    return Response.json(
+      { ok: false, error: { code: 'conflict_abort_failed', message } },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,30 @@
+import { callOrchestratorTool } from '@/lib/orchestrator-tools.js';
+import { 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 filePath = new URL(req.url).searchParams.get('path');
+  const repoRoot = await resolveProjectRoot(project);
+
+  try {
+    const response = await callOrchestratorTool(
+      'repo.conflict_files',
+      { feature_id: id, ...(filePath ? { path: filePath } : {}) },
+      { mutating: false, featureId: id, repoRoot },
+    );
+
+    return Response.json(response, { status: response.ok ? 200 : 409 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to read conflict files';
+    return Response.json(
+      { ok: false, error: { code: 'conflict_files_read_failed', message } },
+      { status: 500 },
+    );
+  }
+}