agentic-orchestrator 0.1.28 → 0.2.1

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

@@ -77,7 +77,19 @@ export async function GET(req: Request): Promise<Response> {
   const repoRoot = await resolveProjectRoot(project);
   const policy = await readPolicyYaml(repoRoot);
   const availability = await getAvailability(req, project, policy);
-  return Response.json(okEnvelope(availability, { source: 'artifact' }));
+  return Response.json(
+    okEnvelope(
+      {
+        ...availability,
+        action_state: {
+          enabled: availability.enabled,
+          authorized: availability.authorized,
+          reason: availability.reason,
+        },
+      },
+      { source: 'artifact' },
+    ),
+  );
 }
 
 export async function POST(req: Request): Promise<Response> {
@@ -88,7 +100,14 @@ export async function POST(req: Request): Promise<Response> {
   const availability = await getAvailability(req, project, policy);
   if (!availability.available) {
     return Response.json(
-      errorEnvelope('unauthorized_action', availability.reason ?? 'Action not authorized'),
+      {
+        ...errorEnvelope('unauthorized_action', availability.reason ?? 'Action not authorized'),
+        action_state: {
+          enabled: availability.enabled,
+          authorized: availability.authorized,
+          reason: availability.reason,
+        },
+      },
       { status: 403 },
     );
   }
@@ -154,6 +173,11 @@ export async function POST(req: Request): Promise<Response> {
         feature_id: featureId,
         goal,
         status: 'initialized',
+        action_state: {
+          enabled: availability.enabled,
+          authorized: availability.authorized,
+          reason: availability.reason,
+        },
       },
       { source: 'tool' },
     ),

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

@@ -0,0 +1,227 @@
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+import {
+  featureExistsInIndex,
+  normalizeRunHistory,
+  readFeatureStateFrontMatter,
+  readFeaturesIndex,
+  readJsonLinesFile,
+  resolveRunEntry,
+  runtimeEventsPath,
+} from '@/lib/runtime-files.js';
+
+export const dynamic = 'force-dynamic';
+
+type WorkerEvent = {
+  ts?: string;
+  run_id?: string;
+  feature_id?: string;
+  role?: string;
+  phase?: string;
+  event_type?: string;
+  output_types?: string[];
+  patch_count?: number;
+  plan_submission_count?: number;
+  request_count?: number;
+  note_count?: number;
+  valid?: boolean;
+  error_code?: string | null;
+  provider?: string;
+  model?: string;
+  watchdog_reason?: string | null;
+  signal?: string | null;
+  exit_code?: number;
+  timeout_ms?: number;
+  elapsed_ms?: number;
+};
+
+const MAX_EVENTS_BYTES = 10 * 1024 * 1024;
+
+function parseLimit(value: string | null, fallback: number): number {
+  const parsed = Number.parseInt(value ?? '', 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return Math.min(parsed, 500);
+}
+
+function parseOffset(value: string | null): number {
+  const parsed = Number.parseInt(value ?? '', 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return 0;
+  }
+  return parsed;
+}
+
+function parseList(value: string | null): string[] {
+  if (!value) {
+    return [];
+  }
+  return value
+    .split(',')
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+}
+
+function parseTimestamp(value: string): number {
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+export async function GET(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const featureId = url.searchParams.get('feature_id')?.trim() ?? '';
+  const project = url.searchParams.get('project');
+  const requestedRunId = url.searchParams.get('run_id');
+  const limit = parseLimit(url.searchParams.get('limit'), 100);
+  const offset = parseOffset(url.searchParams.get('offset'));
+  const eventTypeFilter = new Set(parseList(url.searchParams.get('event_type')));
+  const roleFilter = new Set(parseList(url.searchParams.get('role')));
+  const validFilter = url.searchParams.get('valid')?.toLowerCase();
+
+  if (!featureId) {
+    return Response.json(errorEnvelope('invalid_argument', 'feature_id is required'), {
+      status: 400,
+    });
+  }
+
+  const resolvedRoot = await resolveProjectRoot(project);
+  const repoRoot = !project && process.env.AOP_ROOT ? process.env.AOP_ROOT : resolvedRoot;
+  const index = await readFeaturesIndex(repoRoot);
+  if (!index || !featureExistsInIndex(index, featureId)) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${featureId} not found`), {
+      status: 404,
+    });
+  }
+
+  let frontMatter: Record<string, unknown>;
+  try {
+    const parsed = await readFeatureStateFrontMatter(featureId, repoRoot);
+    frontMatter = parsed.frontMatter;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+    if (code === 'ENOENT') {
+      return Response.json(errorEnvelope('state_not_found', 'Feature state not found'), {
+        status: 404,
+      });
+    }
+    return Response.json(errorEnvelope('state_parse_error', 'Unable to parse feature state'), {
+      status: 500,
+    });
+  }
+
+  const runHistory = normalizeRunHistory(frontMatter.run_history);
+  const runEntry = resolveRunEntry(runHistory, requestedRunId ?? null);
+  if (!runEntry) {
+    return Response.json(errorEnvelope('run_not_found', 'No run history available'), {
+      status: 404,
+    });
+  }
+  if (requestedRunId && runEntry.run_id !== requestedRunId) {
+    return Response.json(errorEnvelope('run_not_found', 'Run history entry not found'), {
+      status: 404,
+    });
+  }
+
+  const eventsPath = runtimeEventsPath(repoRoot, runEntry.run_id);
+  let entries: unknown[] = [];
+  try {
+    const parsed = await readJsonLinesFile(eventsPath, MAX_EVENTS_BYTES);
+    entries = parsed.entries;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+    if (code === 'ENOENT') {
+      return Response.json(errorEnvelope('events_not_found', 'Worker events not found'), {
+        status: 404,
+      });
+    }
+    if (code === 'file_too_large') {
+      return Response.json(
+        errorEnvelope('file_too_large', 'Worker events exceed size limits', {
+          retryable: false,
+        }),
+        { status: 413 },
+      );
+    }
+    return Response.json(errorEnvelope('events_parse_error', 'Unable to parse worker events'), {
+      status: 500,
+    });
+  }
+
+  const normalized = entries
+    .map((entry) => entry as WorkerEvent)
+    .filter((entry) => entry.feature_id === featureId)
+    .map((entry) => ({
+      ts: entry.ts ?? '',
+      run_id: entry.run_id ?? '',
+      feature_id: entry.feature_id ?? '',
+      role: entry.role ?? '',
+      phase: entry.phase ?? '',
+      event_type: entry.event_type ?? '',
+      output_types: Array.isArray(entry.output_types) ? entry.output_types : [],
+      patch_count: typeof entry.patch_count === 'number' ? entry.patch_count : 0,
+      plan_submission_count:
+        typeof entry.plan_submission_count === 'number' ? entry.plan_submission_count : 0,
+      request_count: typeof entry.request_count === 'number' ? entry.request_count : 0,
+      note_count: typeof entry.note_count === 'number' ? entry.note_count : 0,
+      valid: entry.valid !== false,
+      error_code: entry.error_code ?? null,
+      provider: entry.provider ?? 'unknown',
+      model: entry.model ?? 'unknown',
+      watchdog_reason: entry.watchdog_reason ?? null,
+      signal: entry.signal ?? null,
+      exit_code: entry.exit_code,
+      timeout_ms: entry.timeout_ms,
+      elapsed_ms: entry.elapsed_ms,
+    }))
+    .sort((left, right) => parseTimestamp(right.ts) - parseTimestamp(left.ts));
+
+  const filteredEvents = normalized
+    .filter((entry) => (roleFilter.size > 0 ? roleFilter.has(entry.role ?? '') : true))
+    .filter((entry) =>
+      eventTypeFilter.size > 0 ? eventTypeFilter.has(entry.event_type ?? '') : true,
+    )
+    .filter((entry) => {
+      if (validFilter === 'true') {
+        return entry.valid;
+      }
+      if (validFilter === 'false') {
+        return !entry.valid;
+      }
+      return true;
+    });
+
+  const totalCount = filteredEvents.length;
+  const paged = filteredEvents.slice(offset, offset + limit);
+  const roleOptions = [...new Set(normalized.map((entry) => entry.role).filter(Boolean))].sort(
+    (a, b) => a.localeCompare(b),
+  );
+  const eventTypeOptions = [
+    ...new Set(normalized.map((entry) => entry.event_type).filter(Boolean)),
+  ].sort((a, b) => a.localeCompare(b));
+  const summary = {
+    valid_count: normalized.filter((entry) => entry.valid).length,
+    invalid_count: normalized.filter((entry) => !entry.valid).length,
+  };
+
+  return Response.json(
+    okEnvelope(
+      {
+        run_id: runEntry.run_id,
+        feature_id: featureId,
+        run_info: {
+          started_at: runEntry.started_at,
+          ended_at: runEntry.ended_at,
+          status: runEntry.status,
+        },
+        events: paged,
+        total_count: totalCount,
+        has_more: offset + limit < totalCount,
+        role_options: roleOptions,
+        event_type_options: eventTypeOptions,
+        summary,
+      },
+      { source: 'artifact' },
+    ),
+  );
+}

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

@@ -0,0 +1,269 @@
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+import {
+  featureExistsInIndex,
+  normalizeRunHistory,
+  readFeatureStateFrontMatter,
+  readFeaturesIndex,
+  readJsonFile,
+  resolveRunEntry,
+  runtimeLedgerPath,
+} from '@/lib/runtime-files.js';
+import { readToolDescriptions } from '@/lib/tool-catalog.js';
+
+export const dynamic = 'force-dynamic';
+
+type LedgerEntry = {
+  operation_id?: string;
+  tool_name?: string;
+  request_hash?: string;
+  response?: {
+    ok?: boolean;
+    data?: unknown;
+    error?: { code?: string; message?: string; details?: unknown };
+  };
+  created_at?: string;
+  updated_at?: string;
+};
+
+type LedgerFile = {
+  run_id?: string;
+  updated_at?: string;
+  operations?: Record<string, LedgerEntry>;
+};
+
+type OperationStatus = 'success' | 'partial' | 'failed';
+
+const MAX_LEDGER_BYTES = 10 * 1024 * 1024;
+
+function parseLimit(value: string | null, fallback: number): number {
+  const parsed = Number.parseInt(value ?? '', 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return Math.min(parsed, 500);
+}
+
+function parseOffset(value: string | null): number {
+  const parsed = Number.parseInt(value ?? '', 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return 0;
+  }
+  return parsed;
+}
+
+function parseList(value: string | null): string[] {
+  if (!value) {
+    return [];
+  }
+  return value
+    .split(',')
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+}
+
+function resolveTimestamp(entry: LedgerEntry, fallback?: string): string {
+  if (typeof entry.created_at === 'string') {
+    return entry.created_at;
+  }
+  if (typeof entry.updated_at === 'string') {
+    return entry.updated_at;
+  }
+  return fallback ?? '';
+}
+
+function parseTimestamp(value: string): number {
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+function resolveStatus(entry: LedgerEntry): OperationStatus {
+  const warnings =
+    entry.response?.ok === true &&
+    entry.response?.data &&
+    typeof entry.response.data === 'object' &&
+    Array.isArray((entry.response.data as { warnings?: unknown }).warnings) &&
+    ((entry.response.data as { warnings?: unknown[] }).warnings?.length ?? 0) > 0;
+
+  if (warnings) {
+    return 'partial';
+  }
+  if (entry.response?.ok === true) {
+    return 'success';
+  }
+  return 'failed';
+}
+
+function summarizeResponse(entry: LedgerEntry): string {
+  const status = resolveStatus(entry);
+  if (status === 'failed') {
+    const code = entry.response?.error?.code?.trim();
+    const message = entry.response?.error?.message?.trim();
+    if (code && message) {
+      return `${code}: ${message}`;
+    }
+    if (message) {
+      return message;
+    }
+    if (code) {
+      return code;
+    }
+    return 'The tool call failed.';
+  }
+
+  if (status === 'partial') {
+    const warningCount = Array.isArray(
+      (entry.response?.data as { warnings?: unknown[] } | undefined)?.warnings,
+    )
+      ? ((entry.response?.data as { warnings?: unknown[] }).warnings?.length ?? 0)
+      : 0;
+    return warningCount === 1
+      ? 'Completed with 1 warning.'
+      : `Completed with ${warningCount} warnings.`;
+  }
+
+  return 'Completed successfully.';
+}
+
+export async function GET(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const featureId = url.searchParams.get('feature_id')?.trim() ?? '';
+  const project = url.searchParams.get('project');
+  const requestedRunId = url.searchParams.get('run_id');
+  const limit = parseLimit(url.searchParams.get('limit'), 100);
+  const offset = parseOffset(url.searchParams.get('offset'));
+  const toolFilter = new Set(parseList(url.searchParams.get('tool_name')));
+  const statusFilter = url.searchParams.get('status')?.toLowerCase() ?? 'all';
+
+  if (!featureId) {
+    return Response.json(errorEnvelope('invalid_argument', 'feature_id is required'), {
+      status: 400,
+    });
+  }
+
+  const resolvedRoot = await resolveProjectRoot(project);
+  const repoRoot = !project && process.env.AOP_ROOT ? process.env.AOP_ROOT : resolvedRoot;
+  const toolDescriptions = await readToolDescriptions(repoRoot);
+  const index = await readFeaturesIndex(repoRoot);
+  if (!index || !featureExistsInIndex(index, featureId)) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${featureId} not found`), {
+      status: 404,
+    });
+  }
+
+  let frontMatter: Record<string, unknown>;
+  try {
+    const parsed = await readFeatureStateFrontMatter(featureId, repoRoot);
+    frontMatter = parsed.frontMatter;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+    if (code === 'ENOENT') {
+      return Response.json(errorEnvelope('state_not_found', 'Feature state not found'), {
+        status: 404,
+      });
+    }
+    return Response.json(errorEnvelope('state_parse_error', 'Unable to parse feature state'), {
+      status: 500,
+    });
+  }
+
+  const runHistory = normalizeRunHistory(frontMatter.run_history);
+  const runEntry = resolveRunEntry(runHistory, requestedRunId ?? null);
+  if (!runEntry) {
+    return Response.json(errorEnvelope('run_not_found', 'No run history available'), {
+      status: 404,
+    });
+  }
+  if (requestedRunId && runEntry.run_id !== requestedRunId) {
+    return Response.json(errorEnvelope('run_not_found', 'Run history entry not found'), {
+      status: 404,
+    });
+  }
+
+  const ledgerPath = runtimeLedgerPath(repoRoot, runEntry.run_id);
+  let ledger: LedgerFile;
+  try {
+    const parsed = await readJsonFile<LedgerFile>(ledgerPath, MAX_LEDGER_BYTES);
+    ledger = parsed.data;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+    if (code === 'ENOENT') {
+      return Response.json(errorEnvelope('ledger_not_found', 'Operation ledger not found'), {
+        status: 404,
+      });
+    }
+    if (code === 'file_too_large') {
+      return Response.json(
+        errorEnvelope('file_too_large', 'Operation ledger exceeds size limits', {
+          retryable: false,
+        }),
+        { status: 413 },
+      );
+    }
+    return Response.json(errorEnvelope('ledger_parse_error', 'Unable to parse operation ledger'), {
+      status: 500,
+    });
+  }
+
+  const allOperations = Object.values(ledger.operations ?? {})
+    .filter((entry) => typeof entry.operation_id === 'string')
+    .filter((entry) => entry.operation_id?.includes(featureId))
+    .map((entry) => ({
+      operation_id: entry.operation_id ?? '',
+      tool_name: entry.tool_name ?? '',
+      tool_description:
+        typeof entry.tool_name === 'string'
+          ? (toolDescriptions.get(entry.tool_name) ?? null)
+          : null,
+      request_hash: entry.request_hash ?? '',
+      timestamp: resolveTimestamp(entry, ledger.updated_at),
+      response: entry.response ?? { ok: false },
+      response_summary: summarizeResponse(entry),
+      status: resolveStatus(entry),
+    }))
+    .sort((left, right) => parseTimestamp(right.timestamp) - parseTimestamp(left.timestamp));
+
+  const operations = allOperations
+    .filter((entry) => (toolFilter.size > 0 ? toolFilter.has(entry.tool_name) : true))
+    .filter((entry) => {
+      if (statusFilter === 'success') {
+        return entry.status === 'success' || entry.status === 'partial';
+      }
+      if (statusFilter === 'failed') {
+        return entry.status === 'failed';
+      }
+      return true;
+    });
+
+  const totalCount = operations.length;
+  const paged = operations.slice(offset, offset + limit);
+  const summary = {
+    success_count: allOperations.filter((entry) => entry.status === 'success').length,
+    partial_count: allOperations.filter((entry) => entry.status === 'partial').length,
+    failed_count: allOperations.filter((entry) => entry.status === 'failed').length,
+  };
+  const toolNames = [
+    ...new Set(allOperations.map((entry) => entry.tool_name).filter(Boolean)),
+  ].sort((a, b) => a.localeCompare(b));
+
+  return Response.json(
+    okEnvelope(
+      {
+        run_id: runEntry.run_id,
+        feature_id: featureId,
+        updated_at: ledger.updated_at ?? '',
+        run_info: {
+          started_at: runEntry.started_at,
+          ended_at: runEntry.ended_at,
+          status: runEntry.status,
+        },
+        operations: paged,
+        total_count: totalCount,
+        has_more: offset + limit < totalCount,
+        tool_names: toolNames,
+        summary,
+      },
+      { source: 'artifact' },
+    ),
+  );
+}

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

@@ -0,0 +1,11 @@
+import { readPendingQuestions, 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 items = await readPendingQuestions(repoRoot);
+  return Response.json(okEnvelope({ count: items.length, items }, { source: 'artifact' }));
+}

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

@@ -0,0 +1,80 @@
+import { errorEnvelope, okEnvelope } from '@/lib/api-envelope.js';
+import { resolveProjectRoot } from '@/lib/aop-client.js';
+import {
+  featureExistsInIndex,
+  fileExists,
+  normalizeRunHistory,
+  readFeatureStateFrontMatter,
+  readFeaturesIndex,
+  runtimeEventsPath,
+  runtimeLedgerPath,
+} from '@/lib/runtime-files.js';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const featureId = url.searchParams.get('feature_id')?.trim() ?? '';
+  const project = url.searchParams.get('project');
+
+  if (!featureId) {
+    return Response.json(errorEnvelope('invalid_argument', 'feature_id is required'), {
+      status: 400,
+    });
+  }
+
+  const resolvedRoot = await resolveProjectRoot(project);
+  const repoRoot = !project && process.env.AOP_ROOT ? process.env.AOP_ROOT : resolvedRoot;
+  const index = await readFeaturesIndex(repoRoot);
+  if (!index || !featureExistsInIndex(index, featureId)) {
+    return Response.json(errorEnvelope('feature_not_found', `Feature ${featureId} not found`), {
+      status: 404,
+    });
+  }
+
+  let frontMatter: Record<string, unknown>;
+  try {
+    const parsed = await readFeatureStateFrontMatter(featureId, repoRoot);
+    frontMatter = parsed.frontMatter;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException)?.code;
+    if (code === 'ENOENT') {
+      return Response.json(errorEnvelope('state_not_found', 'Feature state not found'), {
+        status: 404,
+      });
+    }
+    return Response.json(errorEnvelope('state_parse_error', 'Unable to parse feature state'), {
+      status: 500,
+    });
+  }
+
+  const runHistory = normalizeRunHistory(frontMatter.run_history);
+  const runs = await Promise.all(
+    runHistory.map(async (entry) => {
+      const ledgerPath = runtimeLedgerPath(repoRoot, entry.run_id);
+      const eventsPath = runtimeEventsPath(repoRoot, entry.run_id);
+      const [hasOperations, hasEvents] = await Promise.all([
+        fileExists(ledgerPath),
+        fileExists(eventsPath),
+      ]);
+      return {
+        run_id: entry.run_id,
+        started_at: entry.started_at,
+        ended_at: entry.ended_at,
+        status: entry.status,
+        has_operations: hasOperations,
+        has_events: hasEvents,
+      };
+    }),
+  );
+
+  return Response.json(
+    okEnvelope(
+      {
+        feature_id: featureId,
+        runs,
+      },
+      { source: 'artifact' },
+    ),
+  );
+}

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

@@ -1,4 +1,4 @@
-import { readDashboardStatus, resolveProjectRoot } from '@/lib/aop-client.js';
+import { readDashboardStatus, readOrganizerStatus, resolveProjectRoot } from '@/lib/aop-client.js';
 import { okEnvelope } from '@/lib/api-envelope.js';
 
 export const dynamic = 'force-dynamic';
@@ -8,5 +8,7 @@ export async function GET(req: Request): Promise<Response> {
   const project = url.searchParams.get('project');
   const repoRoot = await resolveProjectRoot(project);
   const payload = await readDashboardStatus(repoRoot);
-  return Response.json(okEnvelope(payload, { source: 'derived' }));
+  const instanceId = payload.runtime?.owner_instance_id ?? null;
+  const organizer = await readOrganizerStatus(repoRoot, instanceId);
+  return Response.json(okEnvelope({ ...payload, organizer }, { source: 'derived' }));
 }