@llm-dev-ops/agentics-cli 1.4.47 → 1.4.48

package/dist/bundled-agents/platform-agents/src/agents/risk-score.ts

@@ -1,327 +0,0 @@
-import crypto from "crypto";
-import { z } from "zod";
-import { callClaude, extractJson } from "../claude";
-import { analyzeText, type TextAnalysis } from "../text-analysis";
-
-const InputSchema = z
-  .object({
-    objective: z.string(),
-    text: z.string().optional(),
-    context: z.record(z.unknown()).optional(),
-  })
-  .strict();
-
-interface RiskFactor {
-  factor: string;
-  score: number;
-  weight: number;
-  description: string;
-}
-
-interface RiskResult {
-  overall_risk_score: number;
-  risk_level: "low" | "medium" | "high" | "critical";
-  risk_factors: RiskFactor[];
-  mitigations: string[];
-  confidence: number;
-}
-
-// ---------------------------------------------------------------------------
-// Claude-powered analysis
-// ---------------------------------------------------------------------------
-
-const SYSTEM_PROMPT = `You are an expert risk analyst. Analyze the given objective and produce a thorough, domain-specific risk assessment.
-
-Return ONLY valid JSON (no markdown fences, no explanation) with this exact structure:
-{
-  "overall_risk_score": <number 0-100>,
-  "risk_level": "low" | "medium" | "high" | "critical",
-  "risk_factors": [
-    {
-      "factor": "<specific, domain-relevant risk factor name>",
-      "score": <number 0-100>,
-      "weight": <number 0.0-1.0>,
-      "description": "<2-3 sentence justification derived from the objective>"
-    }
-  ],
-  "mitigations": ["<specific, actionable mitigation>"],
-  "confidence": <number 0.0-1.0>
-}
-
-Rules:
-- Extract DOMAIN-SPECIFIC risk factors from the objective, not generic ones.
-- Include 4-7 risk factors covering: technology risks (migration complexity, vendor lock-in, integration challenges), business risks (timeline, budget, regulatory compliance), and operational risks (team readiness, data migration, rollback strategy) as applicable.
-- All factor weights must sum to 1.0.
-- overall_risk_score must equal the weighted sum of factor scores (rounded).
-- risk_level: <=25 "low", <=50 "medium", <=75 "high", >75 "critical".
-- Provide 3-7 specific, actionable mitigations tied to the identified risks.
-- confidence reflects how much information was available for assessment (0.5-0.95).
-- Every description and mitigation must reference specifics from the objective.`;
-
-async function analyzeWithClaude(
-  objective: string,
-  text: string | undefined,
-  apiKey: string
-): Promise<RiskResult> {
-  const userMsg = text
-    ? `Objective: ${objective}\n\nAdditional context:\n${text}`
-    : `Objective: ${objective}`;
-  const raw = await callClaude(apiKey, SYSTEM_PROMPT, userMsg);
-  const parsed = extractJson<RiskResult>(raw);
-  // Validate and clamp values
-  parsed.overall_risk_score = clamp(Math.round(parsed.overall_risk_score), 0, 100);
-  parsed.confidence = clamp(parsed.confidence, 0, 1);
-  parsed.risk_level = riskLevelFromScore(parsed.overall_risk_score);
-  for (const f of parsed.risk_factors) {
-    f.score = clamp(Math.round(f.score), 0, 100);
-    f.weight = clamp(f.weight, 0, 1);
-  }
-  return parsed;
-}
-
-// ---------------------------------------------------------------------------
-// Heuristic analysis (no API key)
-// ---------------------------------------------------------------------------
-
-function analyzeHeuristic(
-  objective: string,
-  text: string | undefined,
-  context: Record<string, unknown> | undefined
-): RiskResult {
-  const content = `${objective} ${text || ""}`;
-  const ta = analyzeText(content);
-  const factors: RiskFactor[] = [];
-
-  // Build domain-specific risk factors based on what was actually found
-  if (ta.actionType === "migration") {
-    factors.push(buildMigrationRisks(ta, objective));
-  }
-  if (ta.entities.length > 0) {
-    factors.push(buildTechnologyRisks(ta));
-  }
-  if (ta.riskSignals.includes("tight timeline pressure") || ta.constraints.includes("timeline constraint")) {
-    factors.push({
-      factor: `Timeline pressure for ${ta.actionType}`,
-      score: 65,
-      weight: 0,
-      description: `The objective indicates time-sensitive delivery. ${ta.actionType !== "general" ? `A ${ta.actionType} effort under time pressure increases risk of incomplete testing and rushed decision-making.` : "Rushed timelines increase risk of quality issues."}`,
-    });
-  }
-  if (ta.riskSignals.includes("resource constraints") || ta.constraints.includes("resource limitation")) {
-    factors.push({
-      factor: "Resource and capacity risk",
-      score: 60,
-      weight: 0,
-      description: `Resource constraints detected in the objective. Limited staffing or budget for "${truncate(objective, 60)}" may lead to bottlenecks and delivery risk.`,
-    });
-  }
-  if (ta.riskSignals.includes("vendor/third-party dependency")) {
-    factors.push({
-      factor: `Third-party dependency risk`,
-      score: 55,
-      weight: 0,
-      description: `The objective involves external vendor or partner dependencies. This introduces risks around vendor reliability, lock-in, and alignment with ${ta.entities.length > 0 ? ta.entities.join(", ") : "project"} requirements.`,
-    });
-  }
-  if (ta.riskSignals.includes("regulatory/compliance exposure") || ta.constraints.includes("regulatory requirement")) {
-    const complianceEntities = ta.entities.filter((e) =>
-      /PCI|HIPAA|GDPR|SOC|SOX|CCPA|ISO|NIST|FedRAMP/i.test(e)
-    );
-    factors.push({
-      factor: `Compliance risk${complianceEntities.length > 0 ? ` (${complianceEntities.join(", ")})` : ""}`,
-      score: 60,
-      weight: 0,
-      description: `Regulatory or compliance requirements add constraints to the ${ta.actionType}. Non-compliance could result in legal liability, fines, or project delays.`,
-    });
-  }
-  if (ta.riskSignals.includes("data integrity/migration risk")) {
-    factors.push({
-      factor: "Data integrity and migration risk",
-      score: 65,
-      weight: 0,
-      description: `Data migration or transformation is involved. Risks include data loss, corruption, schema incompatibilities, and validation gaps during the transition.`,
-    });
-  }
-  if (ta.riskSignals.includes("security exposure")) {
-    factors.push({
-      factor: "Security exposure risk",
-      score: 55,
-      weight: 0,
-      description: `Security considerations are present in the objective. Changes to systems or infrastructure may introduce new attack surfaces or temporarily weaken security posture.`,
-    });
-  }
-  if (ta.riskSignals.includes("technical complexity") && !factors.some((f) => f.factor.includes("complexity"))) {
-    factors.push({
-      factor: `Technical complexity of ${ta.actionType}`,
-      score: 60,
-      weight: 0,
-      description: `The scope described in "${truncate(objective, 50)}" indicates significant technical complexity involving ${ta.entities.length > 0 ? ta.entities.slice(0, 3).join(", ") : "multiple systems"}.`,
-    });
-  }
-
-  // Ensure we have at least 3 factors
-  if (factors.length < 3) {
-    if (!factors.some((f) => f.factor.toLowerCase().includes("scope"))) {
-      factors.push({
-        factor: `Scope management for ${ta.actionType || "initiative"}`,
-        score: 40,
-        weight: 0,
-        description: `Without clearly bounded scope, "${truncate(objective, 50)}" risks expanding beyond original intent, impacting timelines and resources.`,
-      });
-    }
-    if (factors.length < 3) {
-      factors.push({
-        factor: "Stakeholder alignment risk",
-        score: 35,
-        weight: 0,
-        description: `Ensuring all stakeholders agree on approach, priorities, and success criteria for "${truncate(objective, 50)}" is critical for avoiding mid-project pivots.`,
-      });
-    }
-    if (factors.length < 3) {
-      factors.push({
-        factor: "Execution and delivery risk",
-        score: 40,
-        weight: 0,
-        description: `General execution risk for the described initiative. Unforeseen technical or organizational challenges may arise during implementation.`,
-      });
-    }
-  }
-
-  // Assign weights evenly then adjust
-  const evenWeight = parseFloat((1.0 / factors.length).toFixed(3));
-  for (const f of factors) f.weight = evenWeight;
-  // Fix rounding: give remainder to first factor
-  const remainder = parseFloat((1.0 - evenWeight * factors.length).toFixed(3));
-  if (factors.length > 0) factors[0].weight = parseFloat((factors[0].weight + remainder).toFixed(3));
-
-  // Calculate weighted score
-  const overallRiskScore = clamp(
-    Math.round(factors.reduce((sum, f) => sum + f.score * f.weight, 0)),
-    0,
-    100
-  );
-
-  // Generate mitigations tied to the specific factors
-  const mitigations = factors
-    .filter((f) => f.score >= 40)
-    .map((f) => generateMitigation(f, ta));
-  if (mitigations.length < 2) {
-    mitigations.push(
-      `Establish regular risk review checkpoints throughout the ${ta.actionType} process`
-    );
-  }
-
-  // Confidence based on input richness
-  let confidence = 0.55;
-  if (text) confidence += 0.1;
-  if (context) confidence += 0.05;
-  if (ta.wordCount > 20) confidence += 0.05;
-  if (ta.wordCount > 50) confidence += 0.05;
-  if (ta.entities.length > 0) confidence += 0.05;
-  confidence = clamp(confidence, 0.4, 0.85);
-
-  return {
-    overall_risk_score: overallRiskScore,
-    risk_level: riskLevelFromScore(overallRiskScore),
-    risk_factors: factors,
-    mitigations,
-    confidence,
-  };
-}
-
-function buildMigrationRisks(ta: TextAnalysis, objective: string): RiskFactor {
-  const from = ta.entities.length > 0 ? ta.entities[0] : "source system";
-  const to = ta.entities.length > 1 ? ta.entities[1] : "target system";
-  return {
-    factor: `Migration complexity (${from} to ${to})`,
-    score: 65,
-    weight: 0,
-    description: `Migrating from ${from} to ${to} involves compatibility risks, data transfer challenges, and potential downtime. ${ta.constraints.length > 0 ? `Additional constraints: ${ta.constraints.join(", ")}.` : "Careful planning and rollback strategies are essential."}`,
-  };
-}
-
-function buildTechnologyRisks(ta: TextAnalysis): RiskFactor {
-  const techs = ta.entities.slice(0, 4).join(", ");
-  return {
-    factor: `Technology risk (${techs})`,
-    score: ta.entities.length > 3 ? 60 : 45,
-    weight: 0,
-    description: `The objective involves ${techs}. ${ta.entities.length > 3 ? "Multiple technology dependencies increase integration complexity and potential for compatibility issues." : "Technology-specific risks include learning curve, ecosystem maturity, and vendor support."}`,
-  };
-}
-
-function generateMitigation(factor: RiskFactor, ta: TextAnalysis): string {
-  const name = factor.factor.toLowerCase();
-  if (name.includes("migration"))
-    return `Develop a detailed migration plan with rollback procedures, dry-run testing, and phased cutover for the ${ta.entities.slice(0, 2).join(" to ") || "system"} migration`;
-  if (name.includes("timeline"))
-    return `Build schedule buffers and define a minimum viable scope that can be delivered within the constrained timeline`;
-  if (name.includes("resource"))
-    return `Identify critical skill gaps early and secure dedicated team capacity before the ${ta.actionType} begins`;
-  if (name.includes("compliance") || name.includes("regulatory"))
-    return `Engage compliance/legal review early and build compliance checkpoints into the project plan`;
-  if (name.includes("vendor") || name.includes("third-party"))
-    return `Negotiate SLAs with vendors and identify alternative providers to reduce single-vendor dependency`;
-  if (name.includes("data"))
-    return `Implement data validation and reconciliation procedures at every stage of the data migration pipeline`;
-  if (name.includes("security"))
-    return `Conduct security review and threat modeling before and after system changes`;
-  if (name.includes("technology"))
-    return `Run a proof-of-concept or spike to validate technology choices (${ta.entities.slice(0, 2).join(", ")}) before committing to full implementation`;
-  if (name.includes("scope"))
-    return `Define clear scope boundaries and a formal change-request process to prevent scope creep`;
-  return `Address ${factor.factor} through proactive monitoring, stakeholder communication, and contingency planning`;
-}
-
-// ---------------------------------------------------------------------------
-// Utilities
-// ---------------------------------------------------------------------------
-
-function clamp(n: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, n));
-}
-
-function riskLevelFromScore(score: number): "low" | "medium" | "high" | "critical" {
-  if (score <= 25) return "low";
-  if (score <= 50) return "medium";
-  if (score <= 75) return "high";
-  return "critical";
-}
-
-function truncate(s: string, len: number): string {
-  return s.length > len ? s.slice(0, len) + "..." : s;
-}
-
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-
-export async function handleRiskScore(
-  body: Record<string, unknown>,
-  traceId?: string,
-  apiKey?: string
-): Promise<Record<string, unknown>> {
-  const parsed = InputSchema.parse(body);
-
-  let result: RiskResult;
-  if (apiKey) {
-    try {
-      result = await analyzeWithClaude(parsed.objective, parsed.text, apiKey);
-    } catch {
-      // Fall back to heuristic on any Claude failure
-      result = analyzeHeuristic(parsed.objective, parsed.text, parsed.context);
-    }
-  } else {
-    result = analyzeHeuristic(parsed.objective, parsed.text, parsed.context);
-  }
-
-  return {
-    risk_id: crypto.randomUUID(),
-    objective: parsed.objective,
-    overall_risk_score: result.overall_risk_score,
-    risk_level: result.risk_level,
-    risk_factors: result.risk_factors,
-    mitigations: result.mitigations,
-    confidence: result.confidence,
-  };
-}

package/dist/bundled-agents/platform-agents/src/claude.ts

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.callClaude = callClaude;
-exports.extractJson = extractJson;
-
-const { execFileSync } = require("child_process");
-
-function findClaudeBinary() {
-  for (const name of ["claude", "claude-code"]) {
-    try {
-      const result = execFileSync("which", [name], { encoding: "utf-8", timeout: 5000 }).trim();
-      if (result) return result;
-    } catch {}
-  }
-  throw new Error("Claude Code binary not found. Install: npm i -g @anthropic-ai/claude-code");
-}
-
-let _binary = null;
-function getBinary() {
-  if (!_binary) _binary = findClaudeBinary();
-  return _binary;
-}
-
-async function callClaude(apiKey, systemPrompt, userMessage) {
-  const binary = getBinary();
-  const prompt = systemPrompt + "\n\n" + userMessage;
-  const env = Object.assign({}, process.env, { CI: "1" });
-  // Use short timeout when called from a child process (to avoid blocking the
-  // child's event loop for 120s). The parent will kill us anyway at timeoutMs.
-  const timeoutMs = process.env.AGENTICS_CHILD_PROCESS ? 8000 : 120000;
-  delete env.CLAUDECODE;
-  delete env.AGENTICS_DEV;
-
-  const raw = execFileSync(binary, [
-    "--print", "--output-format", "json", "--model", "claude-sonnet-4-20250514", prompt
-  ], {
-    encoding: "utf-8",
-    timeout: timeoutMs,
-    stdio: ["pipe", "pipe", "pipe"],
-    env: env,
-    maxBuffer: 10 * 1024 * 1024,
-  });
-
-  // Unwrap claude --output-format json envelope
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed.type === "result" && typeof parsed.result === "string") {
-      return parsed.result;
-    }
-    return raw;
-  } catch {
-    return raw;
-  }
-}
-
-function extractJson(text) {
-  const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
-  if (fenceMatch) return JSON.parse(fenceMatch[1].trim());
-  const startIdx = text.search(/[{[]/);
-  if (startIdx >= 0) {
-    const startChar = text[startIdx];
-    const endChar = startChar === "{" ? "}" : "]";
-    let depth = 0;
-    for (let i = startIdx; i < text.length; i++) {
-      if (text[i] === startChar) depth++;
-      else if (text[i] === endChar) depth--;
-      if (depth === 0) return JSON.parse(text.slice(startIdx, i + 1));
-    }
-  }
-  return JSON.parse(text.trim());
-}

package/dist/bundled-agents/platform-agents/src/cors.ts

@@ -1,24 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "http";
-
-export function setCorsHeaders(res: ServerResponse): void {
-  res.setHeader("Access-Control-Allow-Origin", "*");
-  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-  res.setHeader(
-    "Access-Control-Allow-Headers",
-    "Content-Type, Authorization, X-Correlation-ID"
-  );
-  res.setHeader("Access-Control-Max-Age", "86400");
-}
-
-export function handleCors(
-  req: IncomingMessage,
-  res: ServerResponse
-): boolean {
-  setCorsHeaders(res);
-  if (req.method === "OPTIONS") {
-    res.writeHead(204);
-    res.end();
-    return true;
-  }
-  return false;
-}

package/dist/bundled-agents/platform-agents/src/envelope.ts

@@ -1,37 +0,0 @@
-import crypto from "crypto";
-
-export interface LayerEntry {
-  layer: string;
-  status: "completed" | "failed" | "skipped";
-  duration_ms?: number;
-}
-
-export interface ExecutionMetadata {
-  trace_id: string;
-  timestamp: string;
-  service: string;
-  execution_id: string;
-}
-
-export interface EnvelopedResponse {
-  data: Record<string, unknown>;
-  execution_metadata: ExecutionMetadata;
-  layers_executed: LayerEntry[];
-}
-
-export function buildEnvelope(
-  data: Record<string, unknown>,
-  layers: LayerEntry[],
-  traceId?: string
-): EnvelopedResponse {
-  return {
-    data,
-    execution_metadata: {
-      trace_id: traceId || crypto.randomUUID(),
-      timestamp: new Date().toISOString(),
-      service: "platform-agents",
-      execution_id: crypto.randomUUID(),
-    },
-    layers_executed: layers,
-  };
-}

package/dist/bundled-agents/platform-agents/src/health.ts

@@ -1,20 +0,0 @@
-import type { ServerResponse } from "http";
-import { setCorsHeaders } from "./cors";
-
-export function handleHealth(res: ServerResponse): void {
-  setCorsHeaders(res);
-  res.writeHead(200, { "Content-Type": "application/json" });
-  res.end(
-    JSON.stringify({
-      status: "healthy",
-      service: "platform-agents",
-      timestamp: new Date().toISOString(),
-      agents: [
-        "decision",
-        "executive-summary",
-        "decision-memo",
-        "risk-score",
-      ],
-    })
-  );
-}

package/dist/bundled-agents/platform-agents/src/index.ts

@@ -1,171 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "http";
-import { handleCors, setCorsHeaders } from "./cors";
-import { handleHealth } from "./health";
-import { resolveAgent } from "./router";
-import { buildEnvelope } from "./envelope";
-import type { LayerEntry } from "./envelope";
-import * as functions from "@google-cloud/functions-framework";
-
-function parseBody(req: IncomingMessage): Promise<Record<string, unknown>> {
-  return new Promise((resolve, reject) => {
-    // Cloud Functions may have already parsed the body
-    if ((req as any).body) {
-      resolve((req as any).body as Record<string, unknown>);
-      return;
-    }
-    const chunks: Buffer[] = [];
-    req.on("data", (chunk: Buffer) => chunks.push(chunk));
-    req.on("end", () => {
-      try {
-        const raw = Buffer.concat(chunks).toString("utf-8");
-        resolve(raw ? JSON.parse(raw) : {});
-      } catch {
-        reject(new Error("Invalid JSON body"));
-      }
-    });
-    req.on("error", reject);
-  });
-}
-
-function sendJson(
-  res: ServerResponse,
-  status: number,
-  body: unknown
-): void {
-  setCorsHeaders(res);
-  res.writeHead(status, { "Content-Type": "application/json" });
-  res.end(JSON.stringify(body));
-}
-
-async function persistToRuvector(
-  data: Record<string, unknown>,
-  traceId: string
-): Promise<void> {
-  const url = process.env.RUVECTOR_SERVICE_URL;
-  if (!url) return;
-
-  try {
-    await fetch(`${url}/v1/vectors/store`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Correlation-ID": traceId,
-      },
-      body: JSON.stringify({
-        source: "platform-agents",
-        trace_id: traceId,
-        payload: data,
-        timestamp: new Date().toISOString(),
-      }),
-      signal: AbortSignal.timeout(5000),
-    });
-  } catch {
-    // Non-blocking, failure-tolerant — silently ignore
-  }
-}
-
-async function handleRequest(
-  req: IncomingMessage,
-  res: ServerResponse
-): Promise<void> {
-  // CORS preflight
-  if (handleCors(req, res)) return;
-
-  const url = (req as any).url || req.url || "/";
-  const path = url.split("?")[0].replace(/\/+$/, "") || "/";
-
-  // Health check
-  if (path === "/health" || path.endsWith("/health")) {
-    handleHealth(res);
-    return;
-  }
-
-  // Route: /v1/platform/<agent-slug>
-  const match = path.match(/\/v1\/platform\/([a-z-]+)$/);
-  if (!match || req.method !== "POST") {
-    sendJson(res, 404, {
-      error: "Not found",
-      message: `No route for ${req.method} ${path}`,
-      available_routes: [
-        "POST /v1/platform/decision",
-        "POST /v1/platform/executive-summary",
-        "POST /v1/platform/decision-memo",
-        "POST /v1/platform/risk-score",
-        "GET /health",
-      ],
-    });
-    return;
-  }
-
-  const slug = match[1];
-  const agent = resolveAgent(slug);
-  if (!agent) {
-    sendJson(res, 404, {
-      error: "Unknown agent",
-      message: `Agent "${slug}" not found`,
-    });
-    return;
-  }
-
-  const traceId =
-    (req.headers["x-correlation-id"] as string) ||
-    crypto.randomUUID();
-
-  let body: Record<string, unknown>;
-  try {
-    body = await parseBody(req);
-  } catch {
-    sendJson(res, 400, buildEnvelope(
-      { error: "Invalid JSON body" },
-      [{ layer: "AGENT_ROUTING", status: "failed" }],
-      traceId
-    ));
-    return;
-  }
-
-  const layers: LayerEntry[] = [
-    { layer: "AGENT_ROUTING", status: "completed" },
-  ];
-
-  const start = performance.now();
-  try {
-    const apiKey =
-      (req.headers["x-anthropic-api-key"] as string) || undefined;
-    const data = await agent.handler(body, traceId, apiKey);
-    const duration_ms = Math.round(performance.now() - start);
-
-    layers.push({
-      layer: agent.layerName,
-      status: "completed",
-      duration_ms,
-    });
-
-    const envelope = buildEnvelope(data, layers, traceId);
-    sendJson(res, 200, envelope);
-
-    // Fire-and-forget persistence
-    persistToRuvector(data, traceId);
-  } catch (err: any) {
-    const duration_ms = Math.round(performance.now() - start);
-    layers.push({
-      layer: agent.layerName,
-      status: "failed",
-      duration_ms,
-    });
-
-    const status = err.statusCode || 400;
-    sendJson(
-      res,
-      status,
-      buildEnvelope(
-        { error: err.message || "Agent execution failed" },
-        layers,
-        traceId
-      )
-    );
-  }
-}
-
-import crypto from "crypto";
-
-functions.http("handler", handleRequest);

package/dist/bundled-agents/platform-agents/src/router.ts

@@ -1,38 +0,0 @@
-import { handleDecision } from "./agents/decision";
-import { handleExecutiveSummary } from "./agents/executive-summary";
-import { handleDecisionMemo } from "./agents/decision-memo";
-import { handleRiskScore } from "./agents/risk-score";
-
-export type AgentHandler = (
-  body: Record<string, unknown>,
-  traceId?: string,
-  apiKey?: string
-) => Promise<Record<string, unknown>>;
-
-interface AgentRoute {
-  handler: AgentHandler;
-  layerName: string;
-}
-
-const routes: Record<string, AgentRoute> = {
-  decision: {
-    handler: handleDecision,
-    layerName: "PLATFORM_DECISION",
-  },
-  "executive-summary": {
-    handler: handleExecutiveSummary,
-    layerName: "PLATFORM_EXECUTIVE_SUMMARY",
-  },
-  "decision-memo": {
-    handler: handleDecisionMemo,
-    layerName: "PLATFORM_DECISION_MEMO",
-  },
-  "risk-score": {
-    handler: handleRiskScore,
-    layerName: "PLATFORM_RISK_SCORE",
-  },
-};
-
-export function resolveAgent(slug: string): AgentRoute | undefined {
-  return routes[slug];
-}