@tokensize/agent-router 0.3.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,777 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AGENT_ROUTER_SCHEMA_VERSION: () => AGENT_ROUTER_SCHEMA_VERSION,
+  AGENT_ROUTER_VERSION: () => AGENT_ROUTER_VERSION,
+  RUN_SCHEMA_VERSION: () => RUN_SCHEMA_VERSION,
+  agentFeedbackSchema: () => agentFeedbackSchema,
+  agentModelSchema: () => agentModelSchema,
+  agentRouteRequestSchema: () => agentRouteRequestSchema,
+  agentRouteResponseSchema: () => agentRouteResponseSchema,
+  agentTaskFeaturesSchema: () => agentTaskFeaturesSchema,
+  allowanceSchema: () => allowanceSchema,
+  appendRunEvent: () => appendRunEvent,
+  approvalKindSchema: () => approvalKindSchema,
+  approvalSurfaceSchema: () => approvalSurfaceSchema,
+  clientSurfaceSchema: () => clientSurfaceSchema,
+  deriveRunStatus: () => deriveRunStatus,
+  effectivePolicySchema: () => effectivePolicySchema,
+  executionPlanSchema: () => executionPlanSchema,
+  featurizeAgentTask: () => featurizeAgentTask,
+  harnessIdSchema: () => harnessIdSchema,
+  isTerminalRunStatus: () => isTerminalRunStatus,
+  mergePolicy: () => mergePolicy,
+  permissionProfileSchema: () => permissionProfileSchema,
+  readinessSchema: () => readinessSchema,
+  routingObjectiveSchema: () => routingObjectiveSchema,
+  runActorSchema: () => runActorSchema,
+  runApprovalSchema: () => runApprovalSchema,
+  runCandidateSchema: () => runCandidateSchema,
+  runDocumentSchema: () => runDocumentSchema,
+  runEventSchema: () => runEventSchema,
+  runStatusSchema: () => runStatusSchema,
+  selectAgentRoute: () => selectAgentRoute,
+  taskRoleSchema: () => taskRoleSchema,
+  taskTypeSchema: () => taskTypeSchema,
+  validateTransition: () => validateTransition,
+  workflowSchema: () => workflowSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/contracts.ts
+var import_zod = require("zod");
+var AGENT_ROUTER_SCHEMA_VERSION = 2;
+var AGENT_ROUTER_VERSION = "2026-07-20-allowance-aware-v2";
+var harnessIdSchema = import_zod.z.enum(["codex", "claude", "copilot", "cursor", "opencode", "custom"]);
+var readinessSchema = import_zod.z.enum([
+  "installed",
+  "auth-ready",
+  "model-listed",
+  "invocation-compatible",
+  "live-confirmed"
+]);
+var permissionProfileSchema = import_zod.z.enum(["inspect", "edit", "test", "network"]);
+var taskRoleSchema = import_zod.z.enum(["inspect", "plan", "implement", "review", "test"]);
+var taskTypeSchema = import_zod.z.enum([
+  "bug",
+  "feature",
+  "refactor",
+  "migration",
+  "review",
+  "research",
+  "docs",
+  "test",
+  "unknown"
+]);
+var routingObjectiveSchema = import_zod.z.enum(["quality", "balanced", "tokens", "latency"]);
+var clientSurfaceSchema = import_zod.z.enum(["cli", "skill", "codex-plugin", "opencode-plugin"]);
+var allowanceSchema = import_zod.z.object({
+  status: import_zod.z.enum(["available", "low", "exhausted", "unmetered", "unknown"]),
+  remainingFraction: import_zod.z.number().min(0).max(1).optional(),
+  resetsAt: import_zod.z.iso.datetime().optional(),
+  observedAt: import_zod.z.iso.datetime(),
+  source: import_zod.z.enum(["runtime-reported", "credential-free", "unavailable"])
+});
+var agentModelSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1).max(256),
+  harness: harnessIdSchema,
+  nativeModelId: import_zod.z.string().min(1).max(200),
+  displayName: import_zod.z.string().min(1).max(200),
+  readiness: readinessSchema,
+  authMode: import_zod.z.enum(["subscription", "api-key", "cloud-provider", "local", "unknown"]),
+  productUseApproved: import_zod.z.boolean(),
+  capabilities: import_zod.z.object({
+    tools: import_zod.z.boolean(),
+    vision: import_zod.z.boolean(),
+    structuredOutput: import_zod.z.enum(["none", "json", "jsonl", "schema"]),
+    sessions: import_zod.z.enum(["none", "resume", "continue"]),
+    permissions: import_zod.z.array(permissionProfileSchema).min(1)
+  }),
+  identityProof: import_zod.z.enum(["requested", "runtime-reported", "unavailable"]),
+  qualityPrior: import_zod.z.number().min(0).max(1),
+  tokenEfficiencyPrior: import_zod.z.number().min(0).max(1),
+  latencyPrior: import_zod.z.number().min(0).max(1),
+  allowance: allowanceSchema.optional(),
+  localHistory: import_zod.z.object({
+    verifiedRuns: import_zod.z.number().int().nonnegative(),
+    successRate: import_zod.z.number().min(0).max(1),
+    medianTokens: import_zod.z.number().nonnegative().optional()
+  }).optional()
+});
+var agentTaskFeaturesSchema = import_zod.z.object({
+  role: taskRoleSchema,
+  type: taskTypeSchema,
+  complexity: import_zod.z.number().min(0).max(1),
+  scopeBreadth: import_zod.z.number().min(0).max(1),
+  contextTokens: import_zod.z.number().int().nonnegative(),
+  oracleStrength: import_zod.z.number().min(0).max(1),
+  codeDensity: import_zod.z.number().min(0).max(1),
+  risk: import_zod.z.enum(["low", "medium", "high", "critical"]),
+  languages: import_zod.z.array(import_zod.z.string().min(1).max(50)).max(20),
+  requiredTools: import_zod.z.array(import_zod.z.string().min(1).max(80)).max(30),
+  requiresVision: import_zod.z.boolean(),
+  requiresNetwork: import_zod.z.boolean(),
+  cacheHit: import_zod.z.boolean()
+});
+var agentRouteRequestSchema = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(AGENT_ROUTER_SCHEMA_VERSION),
+  client: import_zod.z.object({
+    surface: clientSurfaceSchema,
+    version: import_zod.z.string().min(1).max(100)
+  }),
+  requestId: import_zod.z.uuid(),
+  installationId: import_zod.z.string().min(8).max(128),
+  routerMode: import_zod.z.enum(["metadata-only", "prompt-assisted"]),
+  task: agentTaskFeaturesSchema,
+  prompt: import_zod.z.string().min(1).max(12e3).optional(),
+  candidates: import_zod.z.array(agentModelSchema).max(100),
+  root: import_zod.z.object({
+    harness: harnessIdSchema,
+    active: import_zod.z.boolean(),
+    modelId: import_zod.z.string().min(1).max(200).optional(),
+    qualityPrior: import_zod.z.number().min(0).max(1).default(0.9),
+    allowance: allowanceSchema.optional()
+  }),
+  policy: import_zod.z.object({
+    objective: routingObjectiveSchema,
+    maxDelegationDepth: import_zod.z.number().int().min(0).max(3),
+    delegationDepth: import_zod.z.number().int().min(0).max(10),
+    allowedHarnesses: import_zod.z.array(harnessIdSchema).max(10).optional(),
+    permissionCeiling: permissionProfileSchema,
+    tokenBudget: import_zod.z.number().int().positive().max(1e7).optional(),
+    wallTimeBudgetMs: import_zod.z.number().int().positive().max(864e5).optional()
+  })
+});
+var workflowSchema = import_zod.z.enum([
+  "root-only",
+  "single-inspector",
+  "single-implementer",
+  "implementer-deterministic-verify",
+  "implementer-independent-review"
+]);
+var executionPlanSchema = import_zod.z.object({
+  workflow: workflowSchema,
+  targetId: import_zod.z.string().min(1).max(256).nullable(),
+  permissionProfile: permissionProfileSchema,
+  maxWallMs: import_zod.z.number().int().positive(),
+  maxTurns: import_zod.z.number().int().positive().max(100),
+  requiresWorktree: import_zod.z.boolean()
+});
+var agentRouteResponseSchema = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(AGENT_ROUTER_SCHEMA_VERSION),
+  requestId: import_zod.z.uuid(),
+  routeId: import_zod.z.uuid(),
+  routerVersion: import_zod.z.string().min(1),
+  expiresAt: import_zod.z.iso.datetime(),
+  plan: executionPlanSchema,
+  fallback: executionPlanSchema,
+  confidence: import_zod.z.number().min(0).max(1),
+  reasonCodes: import_zod.z.array(import_zod.z.string().min(1)).max(20),
+  expected: import_zod.z.object({
+    verifiedSuccess: import_zod.z.number().min(0).max(1),
+    contextTokens: import_zod.z.number().int().nonnegative(),
+    wallTimeMs: import_zod.z.number().int().nonnegative()
+  }),
+  feedbackToken: import_zod.z.string().min(16).max(200)
+});
+var agentFeedbackSchema = import_zod.z.object({
+  schemaVersion: import_zod.z.literal(AGENT_ROUTER_SCHEMA_VERSION),
+  routeId: import_zod.z.uuid(),
+  feedbackToken: import_zod.z.string().min(16).max(200),
+  idempotencyKey: import_zod.z.string().min(1).max(200),
+  status: import_zod.z.enum(["completed", "verified", "failed", "blocked", "cancelled"]),
+  confirmedTargetId: import_zod.z.string().min(1).max(256).nullable(),
+  identityConfirmed: import_zod.z.boolean(),
+  checksPassed: import_zod.z.number().int().nonnegative(),
+  checksFailed: import_zod.z.number().int().nonnegative(),
+  retries: import_zod.z.number().int().nonnegative().max(100),
+  usage: import_zod.z.object({
+    inputTokens: import_zod.z.number().int().nonnegative().optional(),
+    outputTokens: import_zod.z.number().int().nonnegative().optional(),
+    contextTokensEstimated: import_zod.z.number().int().nonnegative(),
+    source: import_zod.z.enum(["reported", "estimated", "unknown"])
+  }),
+  timings: import_zod.z.object({
+    totalMs: import_zod.z.number().int().nonnegative(),
+    routingMs: import_zod.z.number().int().nonnegative(),
+    executionMs: import_zod.z.number().int().nonnegative(),
+    verificationMs: import_zod.z.number().int().nonnegative()
+  }),
+  failureCode: import_zod.z.string().min(1).max(100).optional()
+});
+
+// src/featurize.ts
+function has(text, pattern) {
+  return pattern.test(text);
+}
+function clamp(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function featurizeAgentTask(input) {
+  const text = input.task.trim();
+  const lower = text.toLowerCase();
+  const role = input.role ?? (input.permissionProfile === "inspect" ? "inspect" : "implement");
+  let type = "unknown";
+  if (has(lower, /\b(bug|fix|broken|regression|error|crash)\b/)) type = "bug";
+  else if (has(lower, /\b(refactor|cleanup|restructure|simplif)\w*\b/)) type = "refactor";
+  else if (has(lower, /\b(migrat|upgrade|port)\w*\b/)) type = "migration";
+  else if (has(lower, /\b(review|audit|analyse|analyze|inspect)\b/)) type = "review";
+  else if (has(lower, /\b(test|coverage|spec)\b/)) type = "test";
+  else if (has(lower, /\b(document|readme|docs|guide)\b/)) type = "docs";
+  else if (has(lower, /\b(research|investigate|compare)\b/)) type = "research";
+  else if (has(lower, /\b(add|build|create|implement|ship)\b/)) type = "feature";
+  const codeMatches = text.match(/```|\b(function|class|interface|const|let|SELECT|CREATE TABLE|npm|git)\b/g) ?? [];
+  const codeDensity = clamp(codeMatches.length / Math.max(4, text.split(/\s+/).length / 8));
+  const scopeBreadth = clamp(((input.scopePaths?.length ?? 1) - 1) / 12 + (has(lower, /\b(repo|workspace|all|across)\b/) ? 0.25 : 0));
+  const acceptanceCount = input.acceptance?.length ?? 0;
+  const complexity = clamp(
+    0.16 + Math.min(text.length / 3e3, 0.3) + scopeBreadth * 0.25 + Math.min(acceptanceCount * 0.04, 0.16) + (has(lower, /\b(security|migration|concurrency|distributed|architecture|production)\b/) ? 0.2 : 0)
+  );
+  const risk = has(lower, /\b(secret|credential|payment|production deploy|delete data)\b/) ? "critical" : has(lower, /\b(auth|security|migration|database|deploy|billing)\b/) ? "high" : complexity > 0.65 ? "medium" : "low";
+  const oracleStrength = clamp(
+    (type === "test" || has(lower, /\b(test|typecheck|lint|build|benchmark|acceptance)\b/) ? 0.65 : 0.2) + Math.min(acceptanceCount * 0.05, 0.25)
+  );
+  return {
+    role,
+    type,
+    complexity,
+    scopeBreadth,
+    contextTokens: Math.max(0, Math.round(input.contextTokens ?? text.length / 4)),
+    oracleStrength,
+    codeDensity,
+    risk,
+    languages: [...new Set(input.languages ?? [])].slice(0, 20),
+    requiredTools: [...new Set(input.requiredTools ?? [])].slice(0, 30),
+    requiresVision: has(lower, /\b(image|screenshot|visual|design|browser)\b/),
+    requiresNetwork: input.permissionProfile === "network" || has(lower, /\b(web|internet|latest|browse|api docs)\b/),
+    cacheHit: false
+  };
+}
+
+// src/route.ts
+var QUALITY_EQUIVALENCE_MARGIN = 5e-3;
+var LOW_ALLOWANCE_THRESHOLD = 0.15;
+var permissionRank = {
+  inspect: 0,
+  edit: 1,
+  test: 2,
+  network: 3
+};
+function rootPlan() {
+  return {
+    workflow: "root-only",
+    targetId: null,
+    permissionProfile: "inspect",
+    maxWallMs: 3e5,
+    maxTurns: 1,
+    requiresWorktree: false
+  };
+}
+function requiredPermission(request) {
+  if (request.task.requiresNetwork) return "network";
+  if (request.task.role === "test") return "test";
+  if (request.task.role === "implement") return "edit";
+  return "inspect";
+}
+function readinessScore(model) {
+  return {
+    installed: 0,
+    "auth-ready": 0.25,
+    "model-listed": 0.6,
+    "invocation-compatible": 0.85,
+    "live-confirmed": 1
+  }[model.readiness];
+}
+function candidateQuality(request, model) {
+  const history = model.localHistory;
+  const historyQuality = history && history.verifiedRuns >= 3 ? history.successRate : model.qualityPrior;
+  let quality = model.qualityPrior * 0.7 + historyQuality * 0.3;
+  if (request.task.codeDensity > 0.2 && model.capabilities.tools) quality += 0.03;
+  if (request.task.requiresVision && model.capabilities.vision) quality += 0.04;
+  return quality * (0.8 + readinessScore(model) * 0.2);
+}
+function candidateScore(request, model) {
+  const quality = candidateQuality(request, model);
+  switch (request.policy.objective) {
+    case "quality":
+      return quality;
+    case "tokens":
+      return quality * 0.65 + model.tokenEfficiencyPrior * 0.35;
+    case "latency":
+      return quality * 0.65 + model.latencyPrior * 0.35;
+    case "balanced":
+      return quality * 0.7 + model.tokenEfficiencyPrior * 0.2 + model.latencyPrior * 0.1;
+  }
+}
+function allowanceScore(allowance) {
+  if (!allowance || allowance.status === "unknown") return 2;
+  if (allowance.status === "unmetered") return 4;
+  if (allowance.status === "exhausted") return -1;
+  if (allowance.status === "available") return 3 + (allowance.remainingFraction ?? 0);
+  return 1 + (allowance.remainingFraction ?? 0);
+}
+function allowanceConstrained(allowance) {
+  return allowance?.status === "exhausted" || allowance?.status === "low" || allowance?.remainingFraction !== void 0 && allowance.remainingFraction <= LOW_ALLOWANCE_THRESHOLD;
+}
+function workflowFor(request) {
+  if (request.task.role === "inspect" || request.task.role === "plan" || request.task.role === "review") {
+    return "single-inspector";
+  }
+  if (request.task.role === "implement" && request.task.oracleStrength >= 0.4) {
+    return "implementer-deterministic-verify";
+  }
+  if (request.task.role === "implement" && (request.task.risk === "high" || request.task.risk === "critical")) {
+    return "implementer-independent-review";
+  }
+  return "single-implementer";
+}
+function selectAgentRoute(request) {
+  const fallback = rootPlan();
+  const permission = requiredPermission(request);
+  const reasons = [];
+  if (permissionRank[permission] > permissionRank[request.policy.permissionCeiling]) {
+    return {
+      plan: fallback,
+      fallback,
+      confidence: 1,
+      reasonCodes: ["PERMISSION_CEILING_EXCEEDED"],
+      expected: { verifiedSuccess: request.root.qualityPrior, contextTokens: request.task.contextTokens, wallTimeMs: 0 }
+    };
+  }
+  if (request.policy.delegationDepth >= request.policy.maxDelegationDepth) {
+    return {
+      plan: fallback,
+      fallback,
+      confidence: 1,
+      reasonCodes: ["DELEGATION_DEPTH_LIMIT"],
+      expected: { verifiedSuccess: request.root.qualityPrior, contextTokens: request.task.contextTokens, wallTimeMs: 0 }
+    };
+  }
+  const capabilityEligible = request.candidates.filter((candidate) => {
+    if (!candidate.productUseApproved) return false;
+    if (readinessScore(candidate) < 0.6) return false;
+    if (!candidate.capabilities.permissions.includes(permission)) return false;
+    if (request.policy.allowedHarnesses && !request.policy.allowedHarnesses.includes(candidate.harness)) return false;
+    if (request.root.active && candidate.harness === request.root.harness) return false;
+    if (request.task.requiresVision && !candidate.capabilities.vision) return false;
+    return true;
+  });
+  if (capabilityEligible.length === 0) {
+    return {
+      plan: fallback,
+      fallback,
+      confidence: 1,
+      reasonCodes: ["NO_ELIGIBLE_LOCAL_TARGET"],
+      expected: { verifiedSuccess: request.root.qualityPrior, contextTokens: request.task.contextTokens, wallTimeMs: 0 }
+    };
+  }
+  const eligible = capabilityEligible.filter((candidate) => candidate.allowance?.status !== "exhausted");
+  if (eligible.length === 0) {
+    return {
+      plan: fallback,
+      fallback,
+      confidence: 1,
+      reasonCodes: ["LOCAL_ALLOWANCE_EXHAUSTED"],
+      expected: { verifiedSuccess: request.root.qualityPrior, contextTokens: request.task.contextTokens, wallTimeMs: 0 }
+    };
+  }
+  const ranked = eligible.map((candidate) => ({
+    candidate,
+    quality: candidateQuality(request, candidate),
+    score: candidateScore(request, candidate),
+    allowance: allowanceScore(candidate.allowance)
+  }));
+  const qualityCeiling = Math.max(...ranked.map((item) => item.quality));
+  const qualityPeers = ranked.filter((item) => item.quality >= qualityCeiling - QUALITY_EQUIVALENCE_MARGIN);
+  const allowancePeers = [...qualityPeers].sort((a, b) => b.allowance - a.allowance || b.score - a.score || a.candidate.id.localeCompare(b.candidate.id));
+  const rankedByUtility = [...qualityPeers].sort((a, b) => b.score - a.score || a.candidate.id.localeCompare(b.candidate.id));
+  const best = allowancePeers[0];
+  const second = [...allowancePeers, ...ranked.filter((item) => !allowancePeers.includes(item))].filter((item) => item !== best).sort((a, b) => b.score - a.score)[0];
+  const rootIsConstrained = allowanceConstrained(request.root.allowance);
+  const targetHasHealthierAllowance = best.allowance > allowanceScore(request.root.allowance);
+  const quotaReliefIsQualitySafe = rootIsConstrained && targetHasHealthierAllowance && best.quality >= request.root.qualityPrior - QUALITY_EQUIVALENCE_MARGIN;
+  if (request.task.complexity < 0.24 && request.task.scopeBreadth < 0.2 && !quotaReliefIsQualitySafe) {
+    return {
+      plan: fallback,
+      fallback,
+      confidence: 0.9,
+      reasonCodes: ["ROOT_MORE_EFFICIENT_FOR_SMALL_TASK"],
+      expected: { verifiedSuccess: request.root.qualityPrior, contextTokens: request.task.contextTokens, wallTimeMs: 0 }
+    };
+  }
+  const delegationMargin = best.score - request.root.qualityPrior;
+  if (delegationMargin < -0.08 && request.task.complexity < 0.7 && !quotaReliefIsQualitySafe) {
+    return {
+      plan: fallback,
+      fallback,
+      confidence: Math.min(1, Math.abs(delegationMargin) + 0.75),
+      reasonCodes: ["ROOT_EXPECTED_UTILITY_HIGHER"],
+      expected: { verifiedSuccess: request.root.qualityPrior, contextTokens: request.task.contextTokens, wallTimeMs: 0 }
+    };
+  }
+  reasons.push("QUALITY_SAFE_LOCAL_TARGET");
+  if (rootIsConstrained) reasons.push("ROOT_ALLOWANCE_LOW");
+  if (targetHasHealthierAllowance) reasons.push("TARGET_ALLOWANCE_HEALTHIER");
+  if (best.candidate.id !== rankedByUtility[0]?.candidate.id) reasons.push("ALLOWANCE_BALANCED_WITHIN_QUALITY_TIER");
+  if (request.policy.objective === "tokens") reasons.push("TOKEN_EFFICIENCY_OBJECTIVE");
+  if (request.task.oracleStrength >= 0.4) reasons.push("DETERMINISTIC_VERIFICATION_AVAILABLE");
+  const workflow = workflowFor(request);
+  const maxWallMs = Math.min(request.policy.wallTimeBudgetMs ?? 9e5, 36e5);
+  const plan = {
+    workflow,
+    targetId: best.candidate.id,
+    permissionProfile: permission,
+    maxWallMs,
+    maxTurns: Math.max(3, Math.min(30, Math.round(5 + request.task.complexity * 15))),
+    requiresWorktree: permissionRank[permission] >= permissionRank.edit
+  };
+  const estimatedContext = Math.round(
+    request.task.contextTokens * (request.task.cacheHit ? 0.18 : 0.32) + 600 + request.task.scopeBreadth * 1200
+  );
+  return {
+    plan,
+    fallback,
+    confidence: Math.max(0.5, Math.min(0.99, 0.72 + (best.score - (second?.score ?? request.root.qualityPrior)) * 0.8)),
+    reasonCodes: reasons,
+    expected: {
+      verifiedSuccess: Math.max(0, Math.min(1, best.score)),
+      contextTokens: estimatedContext,
+      wallTimeMs: Math.round(6e4 + request.task.complexity * 42e4)
+    }
+  };
+}
+
+// src/run.ts
+var import_zod2 = require("zod");
+var RUN_SCHEMA_VERSION = 3;
+var runStatusSchema = import_zod2.z.enum([
+  "planned",
+  "awaiting-approval",
+  "executing",
+  "verifying",
+  "completed",
+  "failed",
+  "cancelled",
+  "expired"
+]);
+var runActorSchema = import_zod2.z.enum(["router", "root-agent", "delegate", "human", "system"]);
+var approvalKindSchema = import_zod2.z.enum(["subscription-use", "execute", "share-prompt"]);
+var approvalSurfaceSchema = import_zod2.z.enum(["local-cli", "web"]);
+var usageSchema = import_zod2.z.strictObject({
+  inputTokens: import_zod2.z.number().int().nonnegative().optional(),
+  outputTokens: import_zod2.z.number().int().nonnegative().optional(),
+  contextTokensEstimated: import_zod2.z.number().int().nonnegative(),
+  source: import_zod2.z.enum(["reported", "estimated", "unknown"])
+});
+var failureCode = import_zod2.z.string().min(1).max(100);
+var reasonCode = import_zod2.z.string().min(1).max(100);
+var eventBase = {
+  seq: import_zod2.z.number().int().nonnegative(),
+  at: import_zod2.z.iso.datetime(),
+  actor: runActorSchema
+};
+var runEventSchema = import_zod2.z.discriminatedUnion("type", [
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("created"),
+    data: import_zod2.z.strictObject({
+      surface: clientSurfaceSchema,
+      routerMode: import_zod2.z.enum(["metadata-only", "prompt-assisted"])
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("routed"),
+    data: import_zod2.z.strictObject({
+      targetId: import_zod2.z.string().min(1).max(256).nullable(),
+      workflow: executionPlanSchema.shape.workflow,
+      confidence: import_zod2.z.number().min(0).max(1),
+      reasonCodes: import_zod2.z.array(reasonCode).max(20)
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("approval-requested"),
+    data: import_zod2.z.strictObject({
+      kind: approvalKindSchema,
+      harness: harnessIdSchema.optional()
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("approval-granted"),
+    data: import_zod2.z.strictObject({
+      kind: approvalKindSchema,
+      grantedBy: approvalSurfaceSchema
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("approval-denied"),
+    data: import_zod2.z.strictObject({
+      kind: approvalKindSchema,
+      deniedBy: approvalSurfaceSchema
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("execution-started"),
+    data: import_zod2.z.strictObject({
+      targetId: import_zod2.z.string().min(1).max(256),
+      permissionProfile: permissionProfileSchema,
+      worktree: import_zod2.z.boolean()
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("execution-progress"),
+    data: import_zod2.z.strictObject({
+      turn: import_zod2.z.number().int().nonnegative(),
+      elapsedMs: import_zod2.z.number().int().nonnegative()
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("execution-finished"),
+    data: import_zod2.z.strictObject({
+      outcome: import_zod2.z.enum(["success", "failure", "timeout"]),
+      failureCode: failureCode.optional(),
+      elapsedMs: import_zod2.z.number().int().nonnegative(),
+      usage: usageSchema.optional()
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("verification-started"),
+    data: import_zod2.z.strictObject({})
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("verification-finished"),
+    data: import_zod2.z.strictObject({
+      passed: import_zod2.z.boolean(),
+      checksPassed: import_zod2.z.number().int().nonnegative(),
+      checksFailed: import_zod2.z.number().int().nonnegative()
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("feedback"),
+    data: import_zod2.z.strictObject({
+      status: import_zod2.z.enum(["completed", "verified", "failed", "blocked", "cancelled"]),
+      rating: import_zod2.z.number().int().min(1).max(5).optional(),
+      modelChoice: import_zod2.z.enum(["right", "acceptable", "wrong"]).optional(),
+      wouldUseAgain: import_zod2.z.boolean().optional()
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("cancelled"),
+    data: import_zod2.z.strictObject({
+      by: runActorSchema
+    })
+  }),
+  import_zod2.z.strictObject({
+    ...eventBase,
+    type: import_zod2.z.literal("expired"),
+    data: import_zod2.z.strictObject({})
+  })
+]);
+var runCandidateSchema = import_zod2.z.strictObject({
+  id: import_zod2.z.string().min(1).max(256),
+  harness: harnessIdSchema,
+  nativeModelId: import_zod2.z.string().min(1).max(200),
+  readiness: import_zod2.z.enum(["installed", "auth-ready", "model-listed", "invocation-compatible", "live-confirmed"]),
+  authMode: import_zod2.z.enum(["subscription", "api-key", "cloud-provider", "local", "unknown"]),
+  productUseApproved: import_zod2.z.boolean(),
+  capabilities: import_zod2.z.object({
+    tools: import_zod2.z.boolean(),
+    vision: import_zod2.z.boolean(),
+    structuredOutput: import_zod2.z.enum(["none", "json", "jsonl", "schema"]),
+    sessions: import_zod2.z.enum(["none", "resume", "continue"]),
+    permissions: import_zod2.z.array(permissionProfileSchema).min(1)
+  }),
+  identityProof: import_zod2.z.enum(["requested", "runtime-reported", "unavailable"]),
+  qualityPrior: import_zod2.z.number().min(0).max(1),
+  tokenEfficiencyPrior: import_zod2.z.number().min(0).max(1),
+  latencyPrior: import_zod2.z.number().min(0).max(1)
+});
+var effectivePolicySchema = import_zod2.z.strictObject({
+  objective: routingObjectiveSchema,
+  maxDelegationDepth: import_zod2.z.number().int().min(0).max(3),
+  permissionCeiling: permissionProfileSchema,
+  allowedHarnesses: import_zod2.z.array(harnessIdSchema).max(10).optional(),
+  tokenBudget: import_zod2.z.number().int().positive().max(1e7).optional(),
+  wallTimeBudgetMs: import_zod2.z.number().int().positive().max(864e5).optional()
+});
+var runApprovalSchema = import_zod2.z.strictObject({
+  kind: approvalKindSchema,
+  state: import_zod2.z.enum(["pending", "granted", "denied"]),
+  surface: approvalSurfaceSchema.optional(),
+  at: import_zod2.z.iso.datetime()
+});
+var runDocumentSchema = import_zod2.z.strictObject({
+  schemaVersion: import_zod2.z.literal(RUN_SCHEMA_VERSION),
+  runId: import_zod2.z.uuid(),
+  createdAt: import_zod2.z.iso.datetime(),
+  expiresAt: import_zod2.z.iso.datetime(),
+  origin: import_zod2.z.strictObject({
+    surface: clientSurfaceSchema,
+    clientVersion: import_zod2.z.string().min(1).max(100)
+  }),
+  task: agentTaskFeaturesSchema,
+  candidatesSnapshot: import_zod2.z.array(runCandidateSchema).max(100),
+  decision: import_zod2.z.strictObject({
+    plan: executionPlanSchema,
+    fallback: executionPlanSchema,
+    confidence: import_zod2.z.number().min(0).max(1),
+    reasonCodes: import_zod2.z.array(reasonCode).max(20),
+    expected: import_zod2.z.strictObject({
+      verifiedSuccess: import_zod2.z.number().min(0).max(1),
+      contextTokens: import_zod2.z.number().int().nonnegative(),
+      wallTimeMs: import_zod2.z.number().int().nonnegative()
+    }),
+    routerVersion: import_zod2.z.string().min(1).max(100)
+  }),
+  policy: effectivePolicySchema,
+  approvals: import_zod2.z.array(runApprovalSchema).max(20),
+  events: import_zod2.z.array(runEventSchema).max(500),
+  status: runStatusSchema,
+  usage: usageSchema.optional()
+});
+var TERMINAL = /* @__PURE__ */ new Set(["cancelled", "expired"]);
+var ALLOWED = {
+  none: ["created"],
+  planned: ["routed", "approval-requested", "execution-started", "cancelled", "expired"],
+  "awaiting-approval": ["approval-granted", "approval-denied", "cancelled", "expired"],
+  executing: ["execution-progress", "execution-finished", "cancelled", "expired"],
+  verifying: ["verification-finished", "cancelled", "expired"],
+  completed: ["verification-started", "feedback", "expired"],
+  failed: ["verification-started", "feedback", "expired"],
+  cancelled: ["feedback"],
+  expired: []
+};
+function apply(status, event) {
+  switch (event.type) {
+    case "created":
+      return "planned";
+    case "routed":
+      return "planned";
+    case "approval-requested":
+      return "awaiting-approval";
+    case "approval-granted":
+      return "planned";
+    case "approval-denied":
+      return "cancelled";
+    case "execution-started":
+    case "execution-progress":
+      return "executing";
+    case "execution-finished":
+      return event.data.outcome === "success" ? "completed" : "failed";
+    case "verification-started":
+      return "verifying";
+    case "verification-finished":
+      return event.data.passed ? "completed" : "failed";
+    case "feedback":
+      return status === "none" ? "planned" : status;
+    case "cancelled":
+      return "cancelled";
+    case "expired":
+      return "expired";
+  }
+}
+function validateTransition(status, event) {
+  return ALLOWED[status].includes(event.type);
+}
+function deriveRunStatus(events) {
+  let status = "none";
+  for (const event of events) status = apply(status, event);
+  return status;
+}
+function appendRunEvent(events, candidate) {
+  const parsed = runEventSchema.parse(candidate);
+  const expectedSeq = events.length === 0 ? 0 : events[events.length - 1].seq + 1;
+  if (parsed.seq !== expectedSeq) throw new Error(`RUN_EVENT_SEQ: expected seq ${expectedSeq}, received ${parsed.seq}`);
+  const status = deriveRunStatus(events);
+  if (!validateTransition(status, parsed)) {
+    throw new Error(`RUN_EVENT_TRANSITION: ${parsed.type} is not valid from ${status}`);
+  }
+  return [...events, parsed];
+}
+function isTerminalRunStatus(status) {
+  return TERMINAL.has(status) || status === "completed" || status === "failed";
+}
+var permissionRank2 = { inspect: 0, edit: 1, test: 2, network: 3 };
+function lowerPermission(a, b) {
+  return permissionRank2[a] <= permissionRank2[b] ? a : b;
+}
+function mergePolicy(local, hosted = {}) {
+  const allowedHarnesses = local.allowedHarnesses && hosted.allowedHarnesses ? local.allowedHarnesses.filter((harness) => hosted.allowedHarnesses?.includes(harness)) : local.allowedHarnesses ?? hosted.allowedHarnesses;
+  const tokenBudget = local.tokenBudget !== void 0 && hosted.tokenBudget !== void 0 ? Math.min(local.tokenBudget, hosted.tokenBudget) : local.tokenBudget ?? hosted.tokenBudget;
+  const wallTimeBudgetMs = local.wallTimeBudgetMs !== void 0 && hosted.wallTimeBudgetMs !== void 0 ? Math.min(local.wallTimeBudgetMs, hosted.wallTimeBudgetMs) : local.wallTimeBudgetMs ?? hosted.wallTimeBudgetMs;
+  return effectivePolicySchema.parse({
+    objective: local.objective ?? hosted.objective ?? "balanced",
+    maxDelegationDepth: Math.min(local.maxDelegationDepth ?? 1, hosted.maxDelegationDepth ?? 3),
+    permissionCeiling: lowerPermission(local.permissionCeiling ?? "inspect", hosted.permissionCeiling ?? "network"),
+    ...allowedHarnesses === void 0 ? {} : { allowedHarnesses },
+    ...tokenBudget === void 0 ? {} : { tokenBudget },
+    ...wallTimeBudgetMs === void 0 ? {} : { wallTimeBudgetMs }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_ROUTER_SCHEMA_VERSION,
+  AGENT_ROUTER_VERSION,
+  RUN_SCHEMA_VERSION,
+  agentFeedbackSchema,
+  agentModelSchema,
+  agentRouteRequestSchema,
+  agentRouteResponseSchema,
+  agentTaskFeaturesSchema,
+  allowanceSchema,
+  appendRunEvent,
+  approvalKindSchema,
+  approvalSurfaceSchema,
+  clientSurfaceSchema,
+  deriveRunStatus,
+  effectivePolicySchema,
+  executionPlanSchema,
+  featurizeAgentTask,
+  harnessIdSchema,
+  isTerminalRunStatus,
+  mergePolicy,
+  permissionProfileSchema,
+  readinessSchema,
+  routingObjectiveSchema,
+  runActorSchema,
+  runApprovalSchema,
+  runCandidateSchema,
+  runDocumentSchema,
+  runEventSchema,
+  runStatusSchema,
+  selectAgentRoute,
+  taskRoleSchema,
+  taskTypeSchema,
+  validateTransition,
+  workflowSchema
+});
+//# sourceMappingURL=index.cjs.map