@kontextmind/kxm 0.6.0 → 0.7.10

package/plugins/kxm/src/workflow-tui.ts

@@ -0,0 +1,255 @@
+/**
+ * KXM Workflow TUI module for Pi Extension.
+ * Renders active workflow run, stage progress stepper, assigned roles, and model/spend metrics.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "./sqlite.ts";
+import { repoConfigDirectory } from "./config.ts";
+import { readRoutingRecords, telemetryPath } from "./telemetry.ts";
+
+export interface WorkflowProgressMetrics {
+  totalSpendUsd?: number | undefined;
+  inputTokens?: number | undefined;
+  outputTokens?: number | undefined;
+  cacheReadTokens?: number | undefined;
+  latencyMs?: number | undefined;
+  harness?: string | undefined;
+  model?: string | undefined;
+  effort?: string | undefined;
+  memoryRevision?: string | undefined;
+  transitions?: number | undefined;
+  maxTransitions?: number | undefined;
+}
+
+export interface WorkflowProgressState {
+  runId?: string | undefined;
+  workflowId: string;
+  status: "idle" | "running" | "waiting" | "passed" | "failed" | "completed" | "cancelled";
+  currentStage?: string | undefined;
+  currentRole?: string | undefined;
+  attempt?: number | undefined;
+  maxAttempts?: number | undefined;
+  stages: Array<{
+    id: string;
+    label?: string | undefined;
+    kind?: "agent" | "gate" | "wait" | "approval" | undefined;
+    status: "pending" | "running" | "passed" | "failed" | "waiting" | "cancelled";
+    role?: string | undefined;
+    attempts?: number | undefined;
+  }>;
+  metrics?: WorkflowProgressMetrics | undefined;
+  updatedAt?: string | undefined;
+}
+
+/**
+ * Load current active or latest workflow progress from SQLite state and telemetry.
+ */
+export function loadActiveWorkflowProgress(
+  repoRoot = process.cwd(),
+  targetRunId?: string,
+): WorkflowProgressState | undefined {
+  const dbPath = join(repoConfigDirectory(repoRoot), "state", "kxm.db");
+  if (!existsSync(dbPath)) return undefined;
+
+  let db: DatabaseSync | undefined;
+  try {
+    db = new DatabaseSync(dbPath, { readOnly: true });
+    let row: { record: string } | undefined;
+    if (targetRunId) {
+      row = db.prepare("SELECT record FROM workflow_runs WHERE id = ?").get(targetRunId) as { record: string } | undefined;
+    } else {
+      row = db.prepare(
+        "SELECT record FROM workflow_runs ORDER BY CASE json_extract(record, '$.status') WHEN 'running' THEN 1 WHEN 'waiting' THEN 2 ELSE 3 END, json_extract(record, '$.updatedAt') DESC LIMIT 1",
+      ).get() as { record: string } | undefined;
+    }
+
+    if (!row) return undefined;
+
+    const raw = JSON.parse(row.record) as Record<string, unknown>;
+    const runId = (raw.id as string) || targetRunId;
+    const workflowId = (raw.definitionId as string) || (raw.workflowId as string) || "workflow";
+    const status = (raw.status as WorkflowProgressState["status"]) || "running";
+    const currentStage = (raw.currentStage as string) || undefined;
+    const updatedAt = (raw.updatedAt as string) || undefined;
+
+    const stages: WorkflowProgressState["stages"] = [];
+    const rawStages = Array.isArray(raw.stages) ? raw.stages : [];
+    for (const s of rawStages) {
+      if (s && typeof s === "object") {
+        stages.push({
+          id: String((s as Record<string, unknown>).id || ""),
+          label: (s as Record<string, unknown>).label as string | undefined,
+          kind: (s as Record<string, unknown>).kind as any,
+          status: ((s as Record<string, unknown>).status as any) || "pending",
+          role: (s as Record<string, unknown>).role as string | undefined,
+          attempts: typeof (s as Record<string, unknown>).attempts === "number" ? ((s as Record<string, unknown>).attempts as number) : undefined,
+        });
+      }
+    }
+
+    let metrics: WorkflowProgressMetrics | undefined;
+    try {
+      const logsDir = join(repoConfigDirectory(repoRoot), "logs");
+      const telemFile = telemetryPath(logsDir);
+      if (existsSync(telemFile)) {
+        const records = readRoutingRecords(telemFile);
+        const routingRunId = (routing: (typeof records)[number]["routing"]): string | undefined =>
+          "runId" in routing ? routing.runId : routing.workflowRunId;
+        let matching = records.filter((r) => routingRunId(r.routing) === runId);
+        if (matching.length === 0) {
+          const rawLines = readFileSync(telemFile, "utf8").split(/\r?\n/);
+          for (const line of rawLines) {
+            if (!line.trim()) continue;
+            try {
+              const p = JSON.parse(line) as Record<string, unknown>;
+              const rt = (p.routing || p) as any;
+              if (rt && (routingRunId(rt) === runId || p.runId === runId)) {
+                matching.push({ recordedAt: (p.timestamp as string) || new Date().toISOString(), routing: rt });
+              }
+            } catch {
+              // ignore
+            }
+          }
+        }
+        if (matching.length > 0) {
+          const latest = matching[matching.length - 1]!.routing;
+          let totalSpend = 0;
+          let totalIn = 0;
+          let totalOut = 0;
+          let totalCache = 0;
+          let totalLatency = 0;
+          for (const m of matching) {
+            const rt = m.routing;
+            if (typeof rt.costUsd === "number") totalSpend += rt.costUsd;
+            if ("tokensIn" in rt && typeof rt.tokensIn === "number") totalIn += rt.tokensIn;
+            else if ("tokens" in rt && rt.tokens && typeof (rt.tokens as { input?: unknown }).input === "number") totalIn += (rt.tokens as { input: number }).input;
+            if ("tokensOut" in rt && typeof rt.tokensOut === "number") totalOut += rt.tokensOut;
+            else if ("tokens" in rt && rt.tokens && typeof (rt.tokens as { output?: unknown }).output === "number") totalOut += (rt.tokens as { output: number }).output;
+            if ("cacheReadTokens" in rt && typeof rt.cacheReadTokens === "number") totalCache += rt.cacheReadTokens;
+            else if ("tokens" in rt && rt.tokens && typeof (rt.tokens as { cacheRead?: unknown }).cacheRead === "number") totalCache += (rt.tokens as { cacheRead: number }).cacheRead;
+            if ("latencyMs" in rt && typeof rt.latencyMs === "number") totalLatency += rt.latencyMs;
+          }
+          const latestRecord = latest as unknown as Record<string, unknown>;
+          const latestMetadata = latestRecord.providerMetadata && typeof latestRecord.providerMetadata === "object"
+            ? latestRecord.providerMetadata as Record<string, unknown>
+            : undefined;
+          metrics = {
+            totalSpendUsd: totalSpend,
+            inputTokens: totalIn,
+            outputTokens: totalOut,
+            cacheReadTokens: totalCache,
+            latencyMs: totalLatency,
+            harness: typeof latestRecord.harness === "string" ? latestRecord.harness : (typeof latestMetadata?.harness === "string" ? latestMetadata.harness : undefined),
+            model: typeof latestRecord.effectiveModel === "string" ? latestRecord.effectiveModel : (typeof latestRecord.model === "string" ? latestRecord.model : (typeof latestRecord.requestedModel === "string" ? latestRecord.requestedModel : undefined)),
+            effort: typeof latestRecord.thinking === "string" ? latestRecord.thinking : (typeof latestRecord.reasoningEffort === "string" ? latestRecord.reasoningEffort : undefined),
+          };
+        }
+      }
+    } catch {
+      // Telemetry optional
+    }
+
+    const activeStageObj = stages.find((s) => s.id === currentStage);
+    const currentRole = activeStageObj?.role || (raw.targetAgentName as string) || undefined;
+    const attempt = activeStageObj?.attempts || 1;
+
+    return {
+      runId,
+      workflowId,
+      status,
+      currentStage,
+      currentRole,
+      attempt,
+      stages,
+      metrics,
+      updatedAt,
+    };
+  } catch {
+    return undefined;
+  } finally {
+    try {
+      db?.close();
+    } catch {
+      // ignore
+    }
+  }
+}
+
+/**
+ * Format stage progress indicator into a compact horizontal visual stepper.
+ * e.g.: [✔ implement] ──> [▶ review-arch] ──> [⧗ review-cli] ──> [○ verify]
+ */
+export function formatStageStepper(stages: WorkflowProgressState["stages"], currentStage?: string): string {
+  if (stages.length === 0) {
+    return currentStage ? `[▶ ${currentStage}]` : "[idle]";
+  }
+
+  const parts = stages.map((s) => {
+    let icon = "○"; // pending
+    if (s.status === "passed") icon = "✔";
+    else if (s.id === currentStage || s.status === "running") icon = "▶";
+    else if (s.status === "waiting") icon = "⧗";
+    else if (s.status === "failed") icon = "✖";
+    else if (s.status === "cancelled") icon = "⊘";
+    return `[${icon} ${s.id}]`;
+  });
+
+  return parts.join(" ──> ");
+}
+
+function formatTokenK(tokens?: number): string {
+  if (tokens === undefined || tokens === null) return "0";
+  if (tokens >= 1000) {
+    return `${(tokens / 1000).toFixed(1)}k`;
+  }
+  return String(tokens);
+}
+
+/**
+ * Render Pi Extension live widget lines (for `ctx.ui.setWidget("kxm-workflow", lines)`).
+ */
+export function renderWorkflowWidgetLines(state?: WorkflowProgressState): string[] {
+  if (!state || !state.runId) {
+    return [
+      "┌─ KXM Workflow ──────────────────────────────────────────────────────────────┐",
+      "│ No active workflow running. Use 'kxm workflow start <id>'                   │",
+      "└─────────────────────────────────────────────────────────────────────────────┘",
+    ];
+  }
+
+  const shortRun = state.runId ? state.runId.slice(0, 16) : "-";
+  const header = `┌─ KXM Workflow: ${state.workflowId} (${shortRun}) ─`;
+  const topBorder = header + "─".repeat(Math.max(2, 79 - header.length)) + "┐";
+
+  const stepper = formatStageStepper(state.stages, state.currentStage);
+  const statusStr = state.status.toUpperCase();
+  const attemptStr = state.attempt ? ` (Attempt ${state.attempt})` : "";
+  const roleStr = state.currentRole ? ` · Role: ${state.currentRole}` : "";
+
+  const lines: string[] = [topBorder];
+  lines.push(`│ Stage: ${stepper}`);
+  lines.push(`│ Status: ${statusStr}${attemptStr}${roleStr}`);
+
+  if (state.metrics) {
+    const costStr = state.metrics.totalSpendUsd !== undefined ? `$${state.metrics.totalSpendUsd.toFixed(2)}` : "unmetered";
+    const routeStr = state.metrics.model ? `${state.metrics.harness ?? "pi"}:${state.metrics.model}` : "harness";
+    const effortStr = state.metrics.effort ? ` (${state.metrics.effort})` : "";
+    const inTokens = formatTokenK(state.metrics.inputTokens);
+    const outTokens = formatTokenK(state.metrics.outputTokens);
+    const cacheTokens = formatTokenK(state.metrics.cacheReadTokens);
+    lines.push(`│ Model: ${routeStr}${effortStr} · Spend: ${costStr}`);
+    lines.push(`│ Tokens: In: ${inTokens} | Out: ${outTokens} | Cache: ${cacheTokens}`);
+  }
+
+  lines.push("└" + "─".repeat(78) + "┘");
+  return lines;
+}
+
+/**
+ * Render detailed full-width TUI banner / notification string.
+ */
+export function renderWorkflowTuiText(state?: WorkflowProgressState): string {
+  return renderWorkflowWidgetLines(state).join("\n");
+}

package/plugins/kxm/src/workflow.ts

@@ -3,11 +3,17 @@ import {
   MAX_MESSAGE_TTL_MS,
   MIN_MESSAGE_TTL_MS,
   ProtocolError,
+  TERMINAL_RECEIPT_SCHEMA,
   newId,
   requireString,
+  validateTerminalReceipt,
   type ImprovementArea,
   type JournalCategory,
   type MessageRecord,
+  type TerminalReceipt,
+  type TerminalReceiptEvidence,
+  type TerminalReceiptMetrics,
+  type TerminalReceiptStatus,
   type WorkflowCheckpointStatus,
   type WorkflowEvidenceInput,
   type WorkflowEvidenceReference,
@@ -18,11 +24,16 @@ import {
 export type {
   ImprovementArea,
   JournalCategory,
+  TerminalReceipt,
+  TerminalReceiptEvidence,
+  TerminalReceiptMetrics,
+  TerminalReceiptStatus,
   WorkflowCheckpointStatus,
   WorkflowEvidenceInput,
   WorkflowEvidenceReference,
   WorkflowEvidenceReferenceInput,
 } from "./protocol.ts";
+export { TERMINAL_RECEIPT_SCHEMA, validateTerminalReceipt } from "./protocol.ts";
 
 export type WorkflowRunStatus = "running" | "waiting" | "completed" | "failed";
 export type WorkflowStageStatus = "pending" | "in_progress" | "waiting" | WorkflowCheckpointStatus;
@@ -153,6 +164,8 @@ export interface WorkflowStageDefinition {
   instructions: string;
   requiredEvidence: string[];
   maxAttempts: number;
+  /** Bounded in-place retry limit before audit escalation (default: 2). */
+  autoResumeLimit?: number;
   area?: ImprovementArea;
   evidencePolicies?: WorkflowEvidencePolicies;
   /** Typed outcome map (v0.5). Keys are outcome identities ("passed",
@@ -250,6 +263,13 @@ export interface WorkflowStageState extends WorkflowStageDefinition {
   startedAt?: string;
   completedAt?: string;
   updatedAt?: string;
+  receipt?: TerminalReceipt;
+  auditEscalation?: {
+    reason: string;
+    timestamp: string;
+    ruling?: string;
+    receipt?: TerminalReceipt;
+  };
 }
 
 export interface CapturedOracle {
@@ -1003,12 +1023,18 @@ export function parseWorkflowDefinitions(
         && (!Number.isInteger(stageMaxTransitions) || (stageMaxTransitions as number) < 1 || (stageMaxTransitions as number) > 100)) {
         throw new Error(`stage ${stageId} maxTransitions must be an integer between 1 and 100`);
       }
+      const autoResumeLimit = stage.autoResumeLimit;
+      if (autoResumeLimit !== undefined
+        && (!Number.isInteger(autoResumeLimit) || (autoResumeLimit as number) < 1 || (autoResumeLimit as number) > 20)) {
+        throw new Error(`stage ${stageId} autoResumeLimit must be an integer between 1 and 20`);
+      }
       return {
         id: stageId,
         label: requireString(stage.label ?? stageId, "stage.label", { max: 128 }),
         instructions: requireString(stage.instructions, "stage.instructions", { max: 4_000 }),
         requiredEvidence,
         maxAttempts: maxAttempts as number,
+        ...(autoResumeLimit !== undefined ? { autoResumeLimit: autoResumeLimit as number } : {}),
         ...(area ? { area } : {}),
         ...(evidencePolicies ? { evidencePolicies } : {}),
         ...(on ? { on } : {}),
@@ -1377,6 +1403,31 @@ export function checkpointRun(
       delete run.currentStage;
       return { retry: false, completed: false, run };
     }
+    if (stage.autoResumeLimit !== undefined && stage.attempts >= stage.autoResumeLimit) {
+      stage.status = "in_progress";
+      const reason = summary || `autoResumeLimit of ${stage.autoResumeLimit} reached on stage ${stage.id}`;
+      const receipt = validateTerminalReceipt({
+        schema: TERMINAL_RECEIPT_SCHEMA,
+        status: "audit_escalation",
+        seat: stage.id,
+        runId: run.id,
+        stageId: stage.id,
+        timestamp,
+        host: "pi",
+        model: "default",
+        escalationReason: reason,
+      });
+      const expiresAt = new Date(Date.parse(timestamp) + 24 * 60 * 60 * 1000).toISOString();
+      waitForWorkflowSignal(run, stage.id, "audit_escalation", reason, timestamp, expiresAt);
+      stage.receipt = receipt;
+      stage.auditEscalation = {
+        reason,
+        timestamp,
+        receipt,
+      };
+      return { retry: false, completed: false, run };
+    }
+    stage.status = status;
     // Declared failure outcomes create typed transitions (bounded); the
     // outcome identity defaults to the checkpoint status.
     const outcomeKey = outcome ?? status;
@@ -1546,3 +1597,96 @@ export function approveWorkflowDegradation(
   run.updatedAt = timestamp;
   return { run, approval, created: true };
 }
+
+export function escalateWorkflowStage(
+  run: WorkflowRun,
+  stageId: string,
+  reason: string,
+  timestamp: string,
+  options: {
+    seat?: string;
+    host?: string;
+    model?: string;
+    evidence?: TerminalReceiptEvidence;
+    metrics?: TerminalReceiptMetrics;
+  } = {},
+): { run: WorkflowRun; receipt: TerminalReceipt } {
+  if (run.status !== "running") throw new ProtocolError(409, `workflow is ${run.status}`, "workflow_terminal");
+  const stage = run.stages.find((s) => s.id === stageId);
+  if (!stage) throw new ProtocolError(404, `workflow stage not found: ${stageId}`, "workflow_stage_not_found");
+  if (stage.id !== run.currentStage || stage.status !== "in_progress") {
+    throw new ProtocolError(409, `stage ${stageId} is not currently active`, "workflow_stage_out_of_order");
+  }
+
+  const receipt: TerminalReceipt = validateTerminalReceipt({
+    schema: TERMINAL_RECEIPT_SCHEMA,
+    status: "audit_escalation",
+    seat: options.seat ?? stage.id,
+    runId: run.id,
+    stageId,
+    timestamp,
+    host: options.host ?? "pi",
+    model: options.model ?? "default",
+    escalationReason: reason,
+    ...(options.evidence ? { evidence: options.evidence } : {}),
+    ...(options.metrics ? { metrics: options.metrics } : {}),
+  });
+
+  const expiresAt = new Date(Date.parse(timestamp) + 24 * 60 * 60 * 1000).toISOString();
+  waitForWorkflowSignal(run, stageId, "audit_escalation", reason, timestamp, expiresAt);
+
+  stage.receipt = receipt;
+  stage.auditEscalation = {
+    reason,
+    timestamp,
+    receipt,
+  };
+
+  return { run, receipt };
+}
+
+export function resumeWorkflowFromRuling(
+  run: WorkflowRun,
+  ruling: string,
+  timestamp: string,
+  options: {
+    status?: WorkflowCheckpointStatus;
+    evidence?: WorkflowEvidenceInput;
+  } = {},
+): { retry: boolean; completed: boolean; run: WorkflowRun; stageId: string } {
+  if (run.status !== "waiting" || !run.waiting) {
+    throw new ProtocolError(409, `workflow is ${run.status}`, "workflow_not_waiting");
+  }
+  if (run.waiting.signalKey !== "audit_escalation") {
+    throw new ProtocolError(
+      409,
+      `workflow is waiting for signal '${run.waiting.signalKey}', not 'audit_escalation'`,
+      "workflow_signal_mismatch",
+    );
+  }
+
+  const stageId = run.waiting.stageId;
+  const stage = run.stages.find((s) => s.id === stageId);
+  if (!stage) throw new ProtocolError(404, `workflow stage not found: ${stageId}`, "workflow_stage_not_found");
+
+  const status = options.status ?? "passed";
+  const evidence = options.evidence ?? {};
+
+  if (stage.auditEscalation) {
+    stage.auditEscalation.ruling = ruling;
+    if (stage.auditEscalation.receipt) {
+      stage.auditEscalation.receipt.ruling = ruling;
+    }
+  }
+  stage.summary = `Resumed by operator ruling: ${ruling}`;
+
+  return resumeWorkflowFromSignal(
+    run,
+    "audit_escalation",
+    status,
+    `Resumed: ${ruling}`,
+    evidence,
+    timestamp,
+  );
+}
+

package/schemas/policy-draft/README.md

@@ -0,0 +1,17 @@
+# Policy-draft schemas (non-authoritative)
+
+`kxm.model.v2` and `kxm.role.v2` here are **passive scaffolding**. They are not
+operator settings, live registry identities, or admission.
+
+- Live project models remain `kxm.model.v1` under `schemas/vnext/`.
+- Live CLI roles remain `kxm.role.v1`.
+- Runner admission remains `.kxm/roster.json` via the trusted control Git loader.
+- This directory is not discovered as a vNext project resource.
+
+Pure validation lives in `plugins/kxm/src/policy-draft.mjs`
+(`validatePolicyDraft`). Callers must supply draft documents, evidence bytes,
+and code-owned ceilings explicitly. The function does not read files, Git,
+credentials, or cwd, and it does not dispatch or admit a route.
+
+Roster `route` lists are configured preference order, not a measured ranking.
+`status: candidate` is stored as candidate data and is never treated as admitted.

package/schemas/policy-draft/model.v2.schema.json

@@ -0,0 +1,140 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://schemas.kxm.dev/policy-draft/model.v2.schema.json",
+  "title": "KXM policy-draft model route",
+  "description": "Passive kxm.model.v2 scaffolding. Not live registry selection, admission, or operator settings.",
+  "type": "object",
+  "required": ["schema", "harness", "model", "vendor", "status", "permissions"],
+  "additionalProperties": false,
+  "properties": {
+    "schema": { "const": "kxm.model.v2" },
+    "id": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$",
+      "minLength": 1,
+      "maxLength": 64
+    },
+    "harness": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$",
+      "minLength": 1,
+      "maxLength": 64
+    },
+    "model": { "type": "string", "minLength": 1, "maxLength": 200 },
+    "vendor": { "type": "string", "minLength": 1, "maxLength": 64 },
+    "status": { "enum": ["admitted", "candidate", "retired"] },
+    "permissions": {
+      "type": "array",
+      "items": { "enum": ["edit", "read-only"] },
+      "minItems": 1,
+      "maxItems": 2,
+      "uniqueItems": true
+    },
+    "origin": {
+      "type": "object",
+      "required": ["source", "sha256"],
+      "additionalProperties": false,
+      "properties": {
+        "source": { "type": "string", "minLength": 1, "maxLength": 512 },
+        "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" }
+      }
+    },
+    "thinking": { "type": "string", "minLength": 1, "maxLength": 64 },
+    "tags": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$",
+        "minLength": 1,
+        "maxLength": 64
+      },
+      "uniqueItems": true,
+      "maxItems": 32
+    },
+    "capabilities": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "pattern": "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$",
+        "minLength": 1,
+        "maxLength": 64
+      },
+      "uniqueItems": true,
+      "maxItems": 32
+    },
+    "priority": { "type": "integer", "minimum": -10000, "maximum": 10000 },
+    "fallbacks": {
+      "type": "array",
+      "maxItems": 8,
+      "items": {
+        "oneOf": [
+          {
+            "type": "object",
+            "required": ["profile"],
+            "additionalProperties": false,
+            "properties": {
+              "profile": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$",
+                "minLength": 1,
+                "maxLength": 64
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["tag"],
+            "additionalProperties": false,
+            "properties": {
+              "tag": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$",
+                "minLength": 1,
+                "maxLength": 64
+              },
+              "capabilities": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "pattern": "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$",
+                  "minLength": 1,
+                  "maxLength": 64
+                },
+                "uniqueItems": true,
+                "maxItems": 32
+              }
+            }
+          },
+          {
+            "type": "object",
+            "required": ["provider", "model"],
+            "additionalProperties": false,
+            "properties": {
+              "provider": {
+                "type": "string",
+                "pattern": "^[a-z][a-z0-9]*(?:[-_][a-z0-9]+)*$",
+                "minLength": 1,
+                "maxLength": 64
+              },
+              "model": { "type": "string", "minLength": 1, "maxLength": 200 }
+            }
+          }
+        ]
+      }
+    },
+    "limits": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "contextTokens": { "type": "integer", "minimum": 1 },
+        "outputTokens": { "type": "integer", "minimum": 1 },
+        "timeoutMs": { "type": "integer", "minimum": 0, "maximum": 31536000000 }
+      }
+    }
+  },
+  "if": {
+    "properties": { "harness": { "const": "pi" } },
+    "required": ["harness"]
+  },
+  "then": { "required": ["origin"] }
+}