@codmir/contracts 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1970 @@
+'use strict';
+
+// src/schema.ts
+var DURATION_SYNC_THRESHOLDS = {
+  instant: 5e3,
+  // 5 seconds
+  quick: 3e4,
+  // 30 seconds
+  medium: 12e4,
+  // 2 minutes
+  long: 3e5
+  // 5 minutes (but usually async)
+};
+
+// src/grace.ts
+var DEFAULT_GRACE_EXTENSIONS = {
+  graceVersion: "grace.v1",
+  ethics: {
+    impacts: [],
+    overallRiskScore: 0,
+    requiresHumanReview: false
+  },
+  reversibility: {
+    fullyReversible: true,
+    snapshotBeforeExecution: true,
+    snapshotRetentionMs: 7 * 24 * 60 * 60 * 1e3,
+    // 7 days
+    rollbackStrategy: "full"
+  },
+  humanOversight: {
+    minCheckpoints: 0,
+    allowAutonomous: true
+  },
+  transparency: {
+    logDecisions: true,
+    logsAccessible: true,
+    auditRetentionDays: 90
+  }
+};
+function calculateRiskScore(impacts) {
+  const severityWeights = {
+    none: 0,
+    low: 10,
+    medium: 25,
+    high: 50,
+    critical: 100
+  };
+  if (impacts.length === 0) return 0;
+  const totalWeight = impacts.reduce(
+    (sum, impact) => sum + severityWeights[impact.severity],
+    0
+  );
+  return Math.min(100, totalWeight);
+}
+function requiresHumanReview(impacts) {
+  return impacts.some(
+    (i) => i.severity === "high" || i.severity === "critical"
+  );
+}
+var GRACE_PRINCIPLES = {
+  transparency: "Every action logged, every decision traceable",
+  consent: "Explicit permission scope, no implicit access",
+  reversibility: "Every AI action must be undoable",
+  accountability: "Task attribution, versioned modifications",
+  economicBoundaries: "Token usage limit, execution cost cap",
+  humanDignity: "AI augments, never replaces human judgment on critical decisions",
+  fairness: "Distributed power must not centralize control",
+  sustainability: "Prefer renewable-powered compute when available"
+};
+
+// src/templates.ts
+function getByPath(obj, path) {
+  const parts = path.split(".").filter(Boolean);
+  let cur = obj;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== "object") return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function setByPath(obj, path, value) {
+  const parts = path.split(".").filter(Boolean);
+  if (parts.length === 0) return;
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const p = parts[i];
+    if (cur[p] == null || typeof cur[p] !== "object") {
+      cur[p] = {};
+    }
+    cur = cur[p];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+function deleteByPath(obj, path) {
+  const parts = path.split(".").filter(Boolean);
+  if (parts.length === 0) return;
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const p = parts[i];
+    if (cur[p] == null || typeof cur[p] !== "object") return;
+    cur = cur[p];
+  }
+  delete cur[parts[parts.length - 1]];
+}
+var TEMPLATE_PATTERN = /^\{\{(.+)\}\}$/;
+function isTemplate(value) {
+  return TEMPLATE_PATTERN.test(value);
+}
+function extractTemplatePath(value) {
+  const match = value.match(TEMPLATE_PATTERN);
+  return match ? match[1].trim() : null;
+}
+function resolveTemplates(ctx, input) {
+  if (typeof input === "string") {
+    const path = extractTemplatePath(input);
+    if (path) {
+      const v = getByPath(ctx, path);
+      return v === void 0 ? null : v;
+    }
+    return input;
+  }
+  if (Array.isArray(input)) {
+    return input.map((v) => resolveTemplates(ctx, v));
+  }
+  if (input && typeof input === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(input)) {
+      out[k] = resolveTemplates(ctx, v);
+    }
+    return out;
+  }
+  return input;
+}
+function resolveStepInput(ctx, input) {
+  return resolveTemplates(ctx, input);
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function mergeJson(target, source) {
+  return { ...target, ...source };
+}
+function deepMergeJson(target, source) {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value && typeof value === "object" && !Array.isArray(value) && result[key] && typeof result[key] === "object" && !Array.isArray(result[key])) {
+      result[key] = deepMergeJson(
+        result[key],
+        value
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/conditions.ts
+function evalCondition(ctx, expr) {
+  switch (expr.op) {
+    case "eq": {
+      const actual = getByPath(ctx, expr.path);
+      return jsonEquals(actual, expr.value);
+    }
+    case "neq": {
+      const actual = getByPath(ctx, expr.path);
+      return !jsonEquals(actual, expr.value);
+    }
+    case "gt": {
+      const actual = getByPath(ctx, expr.path);
+      return typeof actual === "number" && actual > expr.value;
+    }
+    case "gte": {
+      const actual = getByPath(ctx, expr.path);
+      return typeof actual === "number" && actual >= expr.value;
+    }
+    case "lt": {
+      const actual = getByPath(ctx, expr.path);
+      return typeof actual === "number" && actual < expr.value;
+    }
+    case "lte": {
+      const actual = getByPath(ctx, expr.path);
+      return typeof actual === "number" && actual <= expr.value;
+    }
+    case "exists": {
+      return getByPath(ctx, expr.path) !== void 0;
+    }
+    case "contains": {
+      const actual = getByPath(ctx, expr.path);
+      if (typeof actual === "string") {
+        return actual.includes(expr.value);
+      }
+      if (Array.isArray(actual)) {
+        return actual.some((item) => jsonEquals(item, expr.value));
+      }
+      return false;
+    }
+    case "startsWith": {
+      const actual = getByPath(ctx, expr.path);
+      return typeof actual === "string" && actual.startsWith(expr.value);
+    }
+    case "endsWith": {
+      const actual = getByPath(ctx, expr.path);
+      return typeof actual === "string" && actual.endsWith(expr.value);
+    }
+    case "and": {
+      return expr.exprs.every((e) => evalCondition(ctx, e));
+    }
+    case "or": {
+      return expr.exprs.some((e) => evalCondition(ctx, e));
+    }
+    case "not": {
+      return !evalCondition(ctx, expr.expr);
+    }
+    default: {
+      return false;
+    }
+  }
+}
+function jsonEquals(a, b) {
+  if (a === b) return true;
+  if (a === void 0 || a === null || b === null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => jsonEquals(item, b[index]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(
+      (key) => jsonEquals(
+        a[key],
+        b[key]
+      )
+    );
+  }
+  return a === b;
+}
+function validateCondition(expr) {
+  switch (expr.op) {
+    case "eq":
+    case "neq":
+      if (typeof expr.path !== "string" || !expr.path) {
+        throw new Error(`Condition ${expr.op} requires a non-empty path`);
+      }
+      break;
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+      if (typeof expr.path !== "string" || !expr.path) {
+        throw new Error(`Condition ${expr.op} requires a non-empty path`);
+      }
+      if (typeof expr.value !== "number") {
+        throw new Error(`Condition ${expr.op} requires a numeric value`);
+      }
+      break;
+    case "exists":
+      if (typeof expr.path !== "string" || !expr.path) {
+        throw new Error(`Condition ${expr.op} requires a non-empty path`);
+      }
+      break;
+    case "contains":
+    case "startsWith":
+    case "endsWith":
+      if (typeof expr.path !== "string" || !expr.path) {
+        throw new Error(`Condition ${expr.op} requires a non-empty path`);
+      }
+      if (typeof expr.value !== "string") {
+        throw new Error(`Condition ${expr.op} requires a string value`);
+      }
+      break;
+    case "and":
+    case "or":
+      if (!Array.isArray(expr.exprs) || expr.exprs.length === 0) {
+        throw new Error(`Condition ${expr.op} requires a non-empty array of expressions`);
+      }
+      for (const subExpr of expr.exprs) {
+        validateCondition(subExpr);
+      }
+      break;
+    case "not":
+      if (!expr.expr) {
+        throw new Error(`Condition not requires an expression`);
+      }
+      validateCondition(expr.expr);
+      break;
+    default: {
+      throw new Error(`Unknown condition operator: ${expr.op}`);
+    }
+  }
+}
+function eq(path, value) {
+  return { op: "eq", path, value };
+}
+function neq(path, value) {
+  return { op: "neq", path, value };
+}
+function exists(path) {
+  return { op: "exists", path };
+}
+function and(...exprs) {
+  return { op: "and", exprs };
+}
+function or(...exprs) {
+  return { op: "or", exprs };
+}
+function not(expr) {
+  return { op: "not", expr };
+}
+function gt(path, value) {
+  return { op: "gt", path, value };
+}
+function gte(path, value) {
+  return { op: "gte", path, value };
+}
+function lt(path, value) {
+  return { op: "lt", path, value };
+}
+function lte(path, value) {
+  return { op: "lte", path, value };
+}
+function contains(path, value) {
+  return { op: "contains", path, value };
+}
+function startsWith(path, value) {
+  return { op: "startsWith", path, value };
+}
+function endsWith(path, value) {
+  return { op: "endsWith", path, value };
+}
+
+// src/validation.ts
+var ContractValidationError = class extends Error {
+  constructor(message, field, details) {
+    super(message);
+    this.field = field;
+    this.details = details;
+    this.name = "ContractValidationError";
+  }
+};
+function validateContract(contract) {
+  const errors = collectValidationErrors(contract);
+  if (errors.length > 0) {
+    throw errors[0];
+  }
+}
+function validateContractSafe(contract) {
+  const errors = collectValidationErrors(contract);
+  if (errors.length === 0) {
+    return { valid: true };
+  }
+  return { valid: false, errors };
+}
+function collectValidationErrors(contract) {
+  const errors = [];
+  if (contract.schemaVersion !== "codmir.contract.v1") {
+    errors.push(
+      new ContractValidationError(
+        `Unsupported schemaVersion: ${contract.schemaVersion}`,
+        "schemaVersion"
+      )
+    );
+  }
+  if (!contract.id || typeof contract.id !== "string") {
+    errors.push(new ContractValidationError("Contract id is required", "id"));
+  }
+  if (!contract.version || typeof contract.version !== "string") {
+    errors.push(new ContractValidationError("Contract version is required", "version"));
+  }
+  if (!contract.title || typeof contract.title !== "string") {
+    errors.push(new ContractValidationError("Contract title is required", "title"));
+  }
+  if (!Array.isArray(contract.triggers) || contract.triggers.length === 0) {
+    errors.push(
+      new ContractValidationError("Contract must have at least one trigger", "triggers")
+    );
+  } else {
+    for (let i = 0; i < contract.triggers.length; i++) {
+      const trigger = contract.triggers[i];
+      if (trigger.type !== "event") {
+        errors.push(
+          new ContractValidationError(
+            `Trigger ${i} has unsupported type: ${trigger.type}`,
+            `triggers[${i}].type`
+          )
+        );
+      }
+      if (!trigger.event || typeof trigger.event !== "string") {
+        errors.push(
+          new ContractValidationError(
+            `Trigger ${i} requires an event pattern`,
+            `triggers[${i}].event`
+          )
+        );
+      }
+    }
+  }
+  if (!Array.isArray(contract.steps) || contract.steps.length === 0) {
+    errors.push(
+      new ContractValidationError("Contract must have at least one step", "steps")
+    );
+  }
+  const stepIds = /* @__PURE__ */ new Set();
+  for (const step of contract.steps) {
+    if (!step.id || typeof step.id !== "string") {
+      errors.push(new ContractValidationError("Step id is required", "steps[].id"));
+      continue;
+    }
+    if (stepIds.has(step.id)) {
+      errors.push(
+        new ContractValidationError(`Duplicate step id: ${step.id}`, `steps.${step.id}`)
+      );
+    }
+    stepIds.add(step.id);
+    const stepErrors = validateStep(step);
+    errors.push(...stepErrors);
+  }
+  if (!contract.entryStepId) {
+    errors.push(
+      new ContractValidationError("entryStepId is required", "entryStepId")
+    );
+  } else if (!stepIds.has(contract.entryStepId)) {
+    errors.push(
+      new ContractValidationError(
+        `entryStepId not found in steps: ${contract.entryStepId}`,
+        "entryStepId"
+      )
+    );
+  }
+  for (const step of contract.steps) {
+    if (step.next != null && !stepIds.has(step.next)) {
+      errors.push(
+        new ContractValidationError(
+          `Step ${step.id} has invalid next: ${step.next}`,
+          `steps.${step.id}.next`
+        )
+      );
+    }
+    if (step.kind === "branch") {
+      const branchStep = step;
+      for (let i = 0; i < branchStep.branches.length; i++) {
+        const branch = branchStep.branches[i];
+        if (!stepIds.has(branch.next)) {
+          errors.push(
+            new ContractValidationError(
+              `Branch step ${step.id} has invalid branch next: ${branch.next}`,
+              `steps.${step.id}.branches[${i}].next`
+            )
+          );
+        }
+      }
+      if (!stepIds.has(branchStep.defaultNext)) {
+        errors.push(
+          new ContractValidationError(
+            `Branch step ${step.id} has invalid defaultNext: ${branchStep.defaultNext}`,
+            `steps.${step.id}.defaultNext`
+          )
+        );
+      }
+    }
+    if (step.kind === "wait") {
+      const waitStep = step;
+      if (waitStep.nextOnTimeout != null && !stepIds.has(waitStep.nextOnTimeout)) {
+        errors.push(
+          new ContractValidationError(
+            `Wait step ${step.id} has invalid nextOnTimeout: ${waitStep.nextOnTimeout}`,
+            `steps.${step.id}.nextOnTimeout`
+          )
+        );
+      }
+    }
+  }
+  if (!contract.limits) {
+    errors.push(new ContractValidationError("Contract limits are required", "limits"));
+  } else {
+    if (typeof contract.limits.maxRunMs !== "number" || contract.limits.maxRunMs <= 0) {
+      errors.push(
+        new ContractValidationError(
+          "limits.maxRunMs must be a positive number",
+          "limits.maxRunMs"
+        )
+      );
+    }
+    if (typeof contract.limits.maxSteps !== "number" || contract.limits.maxSteps <= 0) {
+      errors.push(
+        new ContractValidationError(
+          "limits.maxSteps must be a positive number",
+          "limits.maxSteps"
+        )
+      );
+    }
+  }
+  if (!Array.isArray(contract.permissions)) {
+    errors.push(
+      new ContractValidationError("Contract permissions must be an array", "permissions")
+    );
+  }
+  return errors;
+}
+function validateStep(step, _stepIds) {
+  const errors = [];
+  if (!step.name || typeof step.name !== "string") {
+    errors.push(
+      new ContractValidationError(`Step ${step.id} requires a name`, `steps.${step.id}.name`)
+    );
+  }
+  if (step.if) {
+    try {
+      validateCondition(step.if);
+    } catch (err) {
+      errors.push(
+        new ContractValidationError(
+          `Step ${step.id} has invalid if condition: ${err.message}`,
+          `steps.${step.id}.if`
+        )
+      );
+    }
+  }
+  switch (step.kind) {
+    case "task": {
+      const taskStep = step;
+      if (!taskStep.task || typeof taskStep.task !== "string") {
+        errors.push(
+          new ContractValidationError(
+            `Task step ${step.id} requires a task name`,
+            `steps.${step.id}.task`
+          )
+        );
+      }
+      if (!taskStep.input || typeof taskStep.input !== "object") {
+        errors.push(
+          new ContractValidationError(
+            `Task step ${step.id} requires an input object`,
+            `steps.${step.id}.input`
+          )
+        );
+      }
+      break;
+    }
+    case "llm": {
+      const llmStep = step;
+      if (!llmStep.prompt || typeof llmStep.prompt !== "object") {
+        errors.push(
+          new ContractValidationError(
+            `LLM step ${step.id} requires a prompt object`,
+            `steps.${step.id}.prompt`
+          )
+        );
+      }
+      break;
+    }
+    case "emit": {
+      const emitStep = step;
+      if (!emitStep.event || typeof emitStep.event !== "string") {
+        errors.push(
+          new ContractValidationError(
+            `Emit step ${step.id} requires an event name`,
+            `steps.${step.id}.event`
+          )
+        );
+      }
+      if (!emitStep.payload || typeof emitStep.payload !== "object") {
+        errors.push(
+          new ContractValidationError(
+            `Emit step ${step.id} requires a payload object`,
+            `steps.${step.id}.payload`
+          )
+        );
+      }
+      break;
+    }
+    case "wait": {
+      const waitStep = step;
+      if (!waitStep.event || typeof waitStep.event !== "string") {
+        errors.push(
+          new ContractValidationError(
+            `Wait step ${step.id} requires an event pattern`,
+            `steps.${step.id}.event`
+          )
+        );
+      }
+      break;
+    }
+    case "branch": {
+      const branchStep = step;
+      if (!Array.isArray(branchStep.branches) || branchStep.branches.length === 0) {
+        errors.push(
+          new ContractValidationError(
+            `Branch step ${step.id} requires at least one branch`,
+            `steps.${step.id}.branches`
+          )
+        );
+      } else {
+        for (let i = 0; i < branchStep.branches.length; i++) {
+          const branch = branchStep.branches[i];
+          if (!branch.when) {
+            errors.push(
+              new ContractValidationError(
+                `Branch ${i} in step ${step.id} requires a when condition`,
+                `steps.${step.id}.branches[${i}].when`
+              )
+            );
+          } else {
+            try {
+              validateCondition(branch.when);
+            } catch (err) {
+              errors.push(
+                new ContractValidationError(
+                  `Branch ${i} in step ${step.id} has invalid when condition: ${err.message}`,
+                  `steps.${step.id}.branches[${i}].when`
+                )
+              );
+            }
+          }
+        }
+      }
+      if (!branchStep.defaultNext || typeof branchStep.defaultNext !== "string") {
+        errors.push(
+          new ContractValidationError(
+            `Branch step ${step.id} requires a defaultNext`,
+            `steps.${step.id}.defaultNext`
+          )
+        );
+      }
+      break;
+    }
+    case "transform": {
+      const transformStep = step;
+      if (!transformStep.transforms || typeof transformStep.transforms !== "object") {
+        errors.push(
+          new ContractValidationError(
+            `Transform step ${step.id} requires a transforms object`,
+            `steps.${step.id}.transforms`
+          )
+        );
+      }
+      break;
+    }
+    case "approval": {
+      const approvalStep = step;
+      if (!approvalStep.prompt || typeof approvalStep.prompt !== "string") {
+        errors.push(
+          new ContractValidationError(
+            `Approval step ${step.id} requires a prompt`,
+            `steps.${step.id}.prompt`
+          )
+        );
+      }
+      if (!approvalStep.nextOnApproved || typeof approvalStep.nextOnApproved !== "string") {
+        errors.push(
+          new ContractValidationError(
+            `Approval step ${step.id} requires nextOnApproved`,
+            `steps.${step.id}.nextOnApproved`
+          )
+        );
+      }
+      break;
+    }
+    default: {
+      const unknownStep = step;
+      errors.push(
+        new ContractValidationError(
+          `Step ${unknownStep.id} has unknown kind: ${unknownStep.kind}`,
+          `steps.${unknownStep.id}.kind`
+        )
+      );
+    }
+  }
+  return errors;
+}
+function hasPermission(contract, kind, scope) {
+  return contract.permissions.some((p) => {
+    if (p.kind !== kind) return false;
+    if (!scope) return true;
+    switch (p.kind) {
+      case "event:emit":
+      case "event:read":
+        return matchPattern(p.pattern, scope);
+      case "storage:read":
+      case "storage:write":
+      case "repo:read":
+      case "repo:write":
+        return matchPattern(p.scope, scope);
+      case "http:request":
+        return p.domains.some((d) => matchPattern(d, scope));
+      case "secrets:read":
+        return p.keys.includes(scope);
+      case "llm:invoke":
+        return !p.models || p.models.includes(scope);
+      default:
+        return false;
+    }
+  });
+}
+function matchPattern(pattern, value) {
+  if (pattern === "*") return true;
+  if (pattern.endsWith(".*")) {
+    const prefix = pattern.slice(0, -2);
+    return value === prefix || value.startsWith(prefix + ".");
+  }
+  if (pattern.endsWith("*")) {
+    const prefix = pattern.slice(0, -1);
+    return value.startsWith(prefix);
+  }
+  return pattern === value;
+}
+
+// src/examples/ticket-triage.ts
+var ticketTriageContract = {
+  schemaVersion: "codmir.contract.v1",
+  id: "codmir.ticket-triage",
+  version: "1.0.0",
+  title: "Ticket Triage Agent",
+  description: "Automatically analyzes and triages incoming support tickets using AI classification",
+  triggers: [
+    {
+      type: "event",
+      event: "ticket.created"
+    }
+  ],
+  permissions: [
+    { kind: "event:emit", pattern: "ticket.*" },
+    { kind: "event:emit", pattern: "agent.*" },
+    { kind: "event:read", pattern: "ticket.*" },
+    { kind: "llm:invoke", models: ["gpt-5-mini-2025-08-07", "gpt-5"] }
+  ],
+  limits: {
+    maxRunMs: 6e4,
+    // 1 minute
+    maxSteps: 10,
+    maxLlmCalls: 3,
+    maxTokens: 5e3
+  },
+  entryStepId: "analyze",
+  steps: [
+    // Step 1: Analyze ticket with LLM
+    {
+      id: "analyze",
+      name: "Analyze Ticket",
+      kind: "llm",
+      description: "Use AI to analyze ticket content and extract key information",
+      model: "gpt-5-mini-2025-08-07",
+      prompt: {
+        system: "You are a support ticket analyst. Analyze the ticket and extract: priority (low/medium/high/urgent), category (bug/feature/question/other), sentiment (positive/neutral/negative), and a brief summary.",
+        user: "Ticket Title: {{trigger.title}}\n\nTicket Body:\n{{trigger.body}}"
+      },
+      saveAs: "steps.analysis",
+      temperature: 0.3,
+      maxTokens: 500,
+      next: "classify"
+    },
+    // Step 2: Transform analysis into structured data
+    {
+      id: "classify",
+      name: "Classify Ticket",
+      kind: "transform",
+      description: "Structure the analysis results",
+      transforms: {
+        "classification.priority": "{{steps.analysis.priority}}",
+        "classification.category": "{{steps.analysis.category}}",
+        "classification.sentiment": "{{steps.analysis.sentiment}}",
+        "classification.summary": "{{steps.analysis.summary}}"
+      },
+      next: "check-urgent"
+    },
+    // Step 3: Branch on urgency
+    {
+      id: "check-urgent",
+      name: "Check Urgency",
+      kind: "branch",
+      description: "Route urgent tickets to fast path",
+      branches: [
+        {
+          when: { op: "eq", path: "classification.priority", value: "urgent" },
+          next: "escalate"
+        },
+        {
+          when: { op: "eq", path: "classification.priority", value: "high" },
+          next: "assign-senior"
+        }
+      ],
+      defaultNext: "assign-team"
+    },
+    // Step 4a: Escalate urgent tickets
+    {
+      id: "escalate",
+      name: "Escalate Urgent",
+      kind: "emit",
+      description: "Emit escalation event for urgent tickets",
+      event: "ticket.escalated",
+      payload: {
+        ticketId: "{{trigger.id}}",
+        priority: "urgent",
+        reason: "Auto-escalated by triage agent",
+        analysis: "{{classification}}"
+      },
+      next: "notify-complete"
+    },
+    // Step 4b: Assign to senior team
+    {
+      id: "assign-senior",
+      name: "Assign to Senior",
+      kind: "task",
+      description: "Assign high-priority ticket to senior team",
+      task: "assign-ticket",
+      input: {
+        ticketId: "{{trigger.id}}",
+        team: "senior-support",
+        priority: "high",
+        notes: "{{classification.summary}}"
+      },
+      saveAs: "steps.assignment",
+      next: "notify-complete"
+    },
+    // Step 4c: Assign to regular team
+    {
+      id: "assign-team",
+      name: "Assign to Team",
+      kind: "task",
+      description: "Assign ticket to appropriate team based on category",
+      task: "assign-ticket",
+      input: {
+        ticketId: "{{trigger.id}}",
+        team: "{{classification.category}}-team",
+        priority: "{{classification.priority}}",
+        notes: "{{classification.summary}}"
+      },
+      saveAs: "steps.assignment",
+      next: "notify-complete"
+    },
+    // Step 5: Emit completion event
+    {
+      id: "notify-complete",
+      name: "Notify Complete",
+      kind: "emit",
+      description: "Emit triage completion event",
+      event: "ticket.triaged",
+      payload: {
+        ticketId: "{{trigger.id}}",
+        classification: "{{classification}}",
+        assignment: "{{steps.assignment}}"
+      },
+      next: null
+    }
+  ],
+  outputs: {
+    onCompleted: [
+      {
+        event: "agent.task.completed",
+        payload: {
+          agent: "ticket-triage",
+          ticketId: "{{trigger.id}}",
+          result: "{{classification}}"
+        }
+      }
+    ],
+    onFailed: [
+      {
+        event: "agent.task.failed",
+        payload: {
+          agent: "ticket-triage",
+          ticketId: "{{trigger.id}}"
+        }
+      }
+    ]
+  },
+  tags: ["support", "triage", "ai", "automation"],
+  author: "codmir-team"
+};
+
+// src/examples/code-review.ts
+var codeReviewContract = {
+  schemaVersion: "codmir.contract.v1",
+  id: "codmir.code-review",
+  version: "1.0.0",
+  title: "Code Review Agent",
+  description: "Automatically reviews pull requests, checks code quality, and suggests improvements",
+  triggers: [
+    {
+      type: "event",
+      event: "github.pull_request.opened"
+    },
+    {
+      type: "event",
+      event: "github.pull_request.synchronize"
+    }
+  ],
+  permissions: [
+    { kind: "event:emit", pattern: "github.*" },
+    { kind: "event:emit", pattern: "review.*" },
+    { kind: "event:read", pattern: "github.*" },
+    { kind: "repo:read", scope: "*" },
+    { kind: "llm:invoke", models: ["gpt-5", "claude-3-sonnet"] },
+    { kind: "http:request", domains: ["api.github.com"] }
+  ],
+  limits: {
+    maxRunMs: 3e5,
+    // 5 minutes
+    maxSteps: 20,
+    maxLlmCalls: 10,
+    maxTokens: 5e4
+  },
+  entryStepId: "fetch-diff",
+  steps: [
+    // Step 1: Fetch PR diff
+    {
+      id: "fetch-diff",
+      name: "Fetch PR Diff",
+      kind: "task",
+      description: "Fetch the pull request diff from GitHub",
+      task: "github-fetch-diff",
+      input: {
+        owner: "{{trigger.repository.owner}}",
+        repo: "{{trigger.repository.name}}",
+        pullNumber: "{{trigger.pull_request.number}}"
+      },
+      saveAs: "steps.diff",
+      timeout: { ms: 3e4 },
+      retry: { maxAttempts: 2, backoffMs: 1e3 },
+      next: "check-size"
+    },
+    // Step 2: Check PR size
+    {
+      id: "check-size",
+      name: "Check PR Size",
+      kind: "branch",
+      description: "Route large PRs differently",
+      branches: [
+        {
+          when: { op: "gt", path: "steps.diff.linesChanged", value: 1e3 },
+          next: "large-pr-warning"
+        }
+      ],
+      defaultNext: "analyze-code"
+    },
+    // Step 2a: Warn about large PR
+    {
+      id: "large-pr-warning",
+      name: "Large PR Warning",
+      kind: "emit",
+      description: "Emit warning about large PR size",
+      event: "review.warning",
+      payload: {
+        pullNumber: "{{trigger.pull_request.number}}",
+        reason: "PR is too large for effective review",
+        linesChanged: "{{steps.diff.linesChanged}}",
+        recommendation: "Consider breaking into smaller PRs"
+      },
+      next: "analyze-code"
+    },
+    // Step 3: Analyze code with LLM
+    {
+      id: "analyze-code",
+      name: "Analyze Code",
+      kind: "llm",
+      description: "Use AI to analyze code changes for issues",
+      model: "gpt-5",
+      systemPrompt: `You are an expert code reviewer. Analyze the diff and identify:
+1. Potential bugs or logic errors
+2. Security vulnerabilities
+3. Performance issues
+4. Code style violations
+5. Missing tests
+6. Documentation gaps
+
+For each issue, provide:
+- File and line number
+- Severity (critical/warning/info)
+- Description
+- Suggested fix
+
+Respond in JSON format with an "issues" array.`,
+      prompt: {
+        diff: "{{steps.diff.content}}",
+        prTitle: "{{trigger.pull_request.title}}",
+        prDescription: "{{trigger.pull_request.body}}"
+      },
+      saveAs: "steps.analysis",
+      temperature: 0.2,
+      maxTokens: 4e3,
+      next: "check-critical"
+    },
+    // Step 4: Check for critical issues
+    {
+      id: "check-critical",
+      name: "Check Critical Issues",
+      kind: "branch",
+      description: "Route critical issues to blocking review",
+      branches: [
+        {
+          when: {
+            op: "exists",
+            path: "steps.analysis.issues"
+          },
+          next: "filter-critical"
+        }
+      ],
+      defaultNext: "approve"
+    },
+    // Step 4a: Filter critical issues
+    {
+      id: "filter-critical",
+      name: "Filter Critical",
+      kind: "transform",
+      description: "Extract critical issues for blocking",
+      transforms: {
+        "review.hasCritical": true,
+        "review.issues": "{{steps.analysis.issues}}"
+      },
+      next: "post-comments"
+    },
+    // Step 5: Post review comments
+    {
+      id: "post-comments",
+      name: "Post Comments",
+      kind: "task",
+      description: "Post review comments on GitHub",
+      task: "github-post-review",
+      input: {
+        owner: "{{trigger.repository.owner}}",
+        repo: "{{trigger.repository.name}}",
+        pullNumber: "{{trigger.pull_request.number}}",
+        body: "## AI Code Review\n\nI found {{review.issues.length}} issue(s) in this PR.",
+        comments: "{{review.issues}}",
+        event: "REQUEST_CHANGES"
+      },
+      saveAs: "steps.reviewPost",
+      next: "wait-author-response"
+    },
+    // Step 6: Wait for author response
+    {
+      id: "wait-author-response",
+      name: "Wait for Response",
+      kind: "wait",
+      description: "Wait for author to address issues or respond",
+      event: "github.pull_request.synchronize",
+      saveEventAs: "events.authorResponse",
+      timeout: { ms: 864e5 },
+      // 24 hours
+      next: "re-analyze",
+      nextOnTimeout: "timeout-reminder"
+    },
+    // Step 6a: Re-analyze after author changes
+    {
+      id: "re-analyze",
+      name: "Re-analyze",
+      kind: "task",
+      description: "Re-fetch and re-analyze after author changes",
+      task: "github-fetch-diff",
+      input: {
+        owner: "{{trigger.repository.owner}}",
+        repo: "{{trigger.repository.name}}",
+        pullNumber: "{{trigger.pull_request.number}}"
+      },
+      saveAs: "steps.newDiff",
+      next: "analyze-code"
+    },
+    // Step 6b: Timeout reminder
+    {
+      id: "timeout-reminder",
+      name: "Timeout Reminder",
+      kind: "emit",
+      description: "Remind author about pending review",
+      event: "review.reminder",
+      payload: {
+        pullNumber: "{{trigger.pull_request.number}}",
+        author: "{{trigger.pull_request.user.login}}",
+        message: "Code review feedback is still pending"
+      },
+      next: null
+    },
+    // Step 7: Approve PR
+    {
+      id: "approve",
+      name: "Approve PR",
+      kind: "task",
+      description: "Approve the PR with positive review",
+      task: "github-post-review",
+      input: {
+        owner: "{{trigger.repository.owner}}",
+        repo: "{{trigger.repository.name}}",
+        pullNumber: "{{trigger.pull_request.number}}",
+        body: "## AI Code Review\n\n\u2705 LGTM! No issues found.",
+        event: "APPROVE"
+      },
+      saveAs: "steps.approval",
+      next: "complete"
+    },
+    // Step 8: Complete
+    {
+      id: "complete",
+      name: "Complete",
+      kind: "emit",
+      description: "Emit review completion event",
+      event: "review.completed",
+      payload: {
+        pullNumber: "{{trigger.pull_request.number}}",
+        repository: "{{trigger.repository.full_name}}",
+        result: "approved"
+      },
+      next: null
+    }
+  ],
+  outputs: {
+    onCompleted: [
+      {
+        event: "agent.task.completed",
+        payload: {
+          agent: "code-review",
+          repository: "{{trigger.repository.full_name}}",
+          pullNumber: "{{trigger.pull_request.number}}"
+        }
+      }
+    ],
+    onFailed: [
+      {
+        event: "agent.task.failed",
+        payload: {
+          agent: "code-review",
+          repository: "{{trigger.repository.full_name}}",
+          pullNumber: "{{trigger.pull_request.number}}"
+        }
+      }
+    ]
+  },
+  tags: ["github", "code-review", "ai", "automation"],
+  author: "codmir-team"
+};
+
+// src/examples/pr-analysis.ts
+var prAnalysisContract = {
+  schemaVersion: "codmir.contract.v1",
+  id: "codmir.pr-analysis",
+  version: "1.0.0",
+  title: "PR Analysis Agent",
+  description: "Automatically analyzes pull requests for code quality, secrets, and best practices when triggered by GitHub App webhook",
+  triggers: [
+    {
+      type: "event",
+      event: "github.pull_request.opened"
+    },
+    {
+      type: "event",
+      event: "github.pull_request.synchronize"
+    },
+    {
+      type: "event",
+      event: "github.pull_request.reopened"
+    },
+    {
+      type: "event",
+      event: "github.pull_request.ready_for_review"
+    }
+  ],
+  permissions: [
+    { kind: "event:emit", pattern: "github.*" },
+    { kind: "event:emit", pattern: "pr.*" },
+    { kind: "event:read", pattern: "github.*" },
+    { kind: "repo:read", scope: "*" },
+    { kind: "http:request", domains: ["api.github.com"] },
+    { kind: "secrets:read", keys: ["GITHUB_TOKEN", "GITHUB_APP_*"] }
+  ],
+  limits: {
+    maxRunMs: 12e4,
+    // 2 minutes
+    maxSteps: 10,
+    maxLlmCalls: 0,
+    // No LLM calls needed for basic analysis
+    maxTokens: 0
+  },
+  entryStepId: "run-analysis",
+  steps: [
+    // Step 1: Run full PR analysis (fetch + analyze + post comment)
+    {
+      id: "run-analysis",
+      name: "Run PR Analysis",
+      kind: "task",
+      description: "Fetch PR info, analyze diff, and post analysis comment",
+      task: "pr-run-analysis",
+      input: {
+        owner: "{{trigger.repository.owner.login}}",
+        repo: "{{trigger.repository.name}}",
+        pullNumber: "{{trigger.pull_request.number}}",
+        installationId: "{{trigger.installation.id}}"
+      },
+      saveAs: "steps.analysis",
+      timeout: { ms: 6e4 },
+      retry: { maxAttempts: 2, backoffMs: 2e3 },
+      next: "check-secrets"
+    },
+    // Step 2: Check for critical issues (secrets detected)
+    {
+      id: "check-secrets",
+      name: "Check for Secrets",
+      kind: "branch",
+      description: "Check if secrets were detected in the PR",
+      branches: [
+        {
+          when: {
+            op: "gt",
+            path: "steps.analysis.analysis.secrets.length",
+            value: 0
+          },
+          next: "emit-secret-alert"
+        }
+      ],
+      defaultNext: "emit-completed"
+    },
+    // Step 2a: Emit secret alert
+    {
+      id: "emit-secret-alert",
+      name: "Emit Secret Alert",
+      kind: "emit",
+      description: "Emit alert about potential secrets detected",
+      event: "pr.secrets.detected",
+      payload: {
+        pullNumber: "{{trigger.pull_request.number}}",
+        repository: "{{trigger.repository.full_name}}",
+        secretCount: "{{steps.analysis.analysis.secrets.length}}",
+        secrets: "{{steps.analysis.analysis.secrets}}",
+        severity: "critical"
+      },
+      next: "emit-completed"
+    },
+    // Step 3: Emit completion event
+    {
+      id: "emit-completed",
+      name: "Emit Completed",
+      kind: "emit",
+      description: "Emit PR analysis completion event",
+      event: "pr.analysis.completed",
+      payload: {
+        pullNumber: "{{trigger.pull_request.number}}",
+        repository: "{{trigger.repository.full_name}}",
+        analysis: "{{steps.analysis.analysis}}",
+        commentPosted: "{{steps.analysis.commentPosted}}",
+        commentId: "{{steps.analysis.commentId}}"
+      },
+      next: null
+    }
+  ],
+  outputs: {
+    onCompleted: [
+      {
+        event: "agent.task.completed",
+        payload: {
+          agent: "pr-analysis",
+          repository: "{{trigger.repository.full_name}}",
+          pullNumber: "{{trigger.pull_request.number}}",
+          result: "{{steps.analysis}}"
+        }
+      }
+    ],
+    onFailed: [
+      {
+        event: "agent.task.failed",
+        payload: {
+          agent: "pr-analysis",
+          repository: "{{trigger.repository.full_name}}",
+          pullNumber: "{{trigger.pull_request.number}}"
+        }
+      }
+    ]
+  },
+  tags: ["github", "pr-analysis", "automation", "webhook"],
+  author: "codmir-team"
+};
+var prAnalysisWithLlmContract = {
+  schemaVersion: "codmir.contract.v1",
+  id: "codmir.pr-analysis-llm",
+  version: "1.0.0",
+  title: "PR Analysis Agent (with AI Review)",
+  description: "Analyzes pull requests with AI-powered code review for deeper insights",
+  triggers: [
+    {
+      type: "event",
+      event: "github.pull_request.opened"
+    },
+    {
+      type: "event",
+      event: "github.pull_request.synchronize"
+    }
+  ],
+  permissions: [
+    { kind: "event:emit", pattern: "github.*" },
+    { kind: "event:emit", pattern: "pr.*" },
+    { kind: "event:read", pattern: "github.*" },
+    { kind: "repo:read", scope: "*" },
+    { kind: "http:request", domains: ["api.github.com"] },
+    { kind: "secrets:read", keys: ["GITHUB_TOKEN", "GITHUB_APP_*"] },
+    { kind: "llm:invoke", models: ["claude-3-sonnet", "claude-3-haiku"] }
+  ],
+  limits: {
+    maxRunMs: 3e5,
+    // 5 minutes
+    maxSteps: 15,
+    maxLlmCalls: 5,
+    maxTokens: 5e4
+  },
+  entryStepId: "fetch-pr",
+  steps: [
+    // Step 1: Fetch PR info
+    {
+      id: "fetch-pr",
+      name: "Fetch PR Info",
+      kind: "task",
+      description: "Fetch pull request metadata from GitHub",
+      task: "pr-fetch-info",
+      input: {
+        owner: "{{trigger.repository.owner.login}}",
+        repo: "{{trigger.repository.name}}",
+        pullNumber: "{{trigger.pull_request.number}}"
+      },
+      saveAs: "steps.pr",
+      timeout: { ms: 15e3 },
+      next: "fetch-files"
+    },
+    // Step 2: Fetch PR files
+    {
+      id: "fetch-files",
+      name: "Fetch PR Files",
+      kind: "task",
+      description: "Fetch changed files with patches",
+      task: "pr-fetch-files",
+      input: {
+        owner: "{{trigger.repository.owner.login}}",
+        repo: "{{trigger.repository.name}}",
+        pullNumber: "{{trigger.pull_request.number}}"
+      },
+      saveAs: "steps.files",
+      timeout: { ms: 3e4 },
+      next: "static-analysis"
+    },
+    // Step 3: Run static analysis
+    {
+      id: "static-analysis",
+      name: "Static Analysis",
+      kind: "task",
+      description: "Run heuristic analysis on PR diff",
+      task: "pr-analyze-diff",
+      input: {
+        pr: "{{steps.pr}}",
+        files: "{{steps.files}}",
+        owner: "{{trigger.repository.owner.login}}",
+        repo: "{{trigger.repository.name}}"
+      },
+      saveAs: "steps.staticAnalysis",
+      timeout: { ms: 3e4 },
+      next: "llm-review"
+    },
+    // Step 4: AI-powered code review
+    {
+      id: "llm-review",
+      name: "AI Code Review",
+      kind: "llm",
+      description: "Use AI to review code changes for issues and improvements",
+      model: "claude-3-sonnet",
+      systemPrompt: `You are an expert code reviewer. Analyze the PR diff and identify:
+1. Potential bugs or logic errors
+2. Security vulnerabilities
+3. Performance issues
+4. Code style violations
+5. Missing error handling
+6. Suggestions for improvement
+
+Be concise and actionable. Focus on the most important issues.
+Respond in JSON format with an "issues" array containing objects with:
+- severity: "critical" | "warning" | "info"
+- file: string (filename)
+- line: number (approximate line if known)
+- issue: string (description)
+- suggestion: string (how to fix)`,
+      prompt: {
+        prTitle: "{{steps.pr.title}}",
+        prDescription: "{{trigger.pull_request.body}}",
+        staticIssues: "{{steps.staticAnalysis.analysis.issues}}",
+        changedFiles: "{{steps.files}}"
+      },
+      saveAs: "steps.llmReview",
+      temperature: 0.2,
+      maxTokens: 4e3,
+      next: "post-comment"
+    },
+    // Step 5: Post combined analysis comment
+    {
+      id: "post-comment",
+      name: "Post Comment",
+      kind: "task",
+      description: "Post analysis and AI review comment to PR",
+      task: "pr-post-comment",
+      input: {
+        owner: "{{trigger.repository.owner.login}}",
+        repo: "{{trigger.repository.name}}",
+        pullNumber: "{{trigger.pull_request.number}}",
+        markdown: "{{steps.staticAnalysis.markdown}}\n\n### \u{1F916} AI Review\n\n{{steps.llmReview.content}}"
+      },
+      saveAs: "steps.comment",
+      timeout: { ms: 15e3 },
+      next: "emit-completed"
+    },
+    // Step 6: Emit completion
+    {
+      id: "emit-completed",
+      name: "Complete",
+      kind: "emit",
+      description: "Emit completion event",
+      event: "pr.analysis.completed",
+      payload: {
+        pullNumber: "{{trigger.pull_request.number}}",
+        repository: "{{trigger.repository.full_name}}",
+        staticAnalysis: "{{steps.staticAnalysis.analysis}}",
+        llmReview: "{{steps.llmReview}}",
+        commentPosted: true
+      },
+      next: null
+    }
+  ],
+  outputs: {
+    onCompleted: [
+      {
+        event: "agent.task.completed",
+        payload: {
+          agent: "pr-analysis-llm",
+          repository: "{{trigger.repository.full_name}}",
+          pullNumber: "{{trigger.pull_request.number}}"
+        }
+      }
+    ],
+    onFailed: [
+      {
+        event: "agent.task.failed",
+        payload: {
+          agent: "pr-analysis-llm",
+          repository: "{{trigger.repository.full_name}}",
+          pullNumber: "{{trigger.pull_request.number}}"
+        }
+      }
+    ]
+  },
+  tags: ["github", "pr-analysis", "ai-review", "automation", "webhook"],
+  author: "codmir-team"
+};
+
+// src/voice/create-ticket.ts
+var voiceCreateTicketContract = {
+  schemaVersion: "codmir.contract.v1",
+  id: "voice.create-ticket",
+  version: "1.0.0",
+  title: "Create Ticket via Voice",
+  description: "Creates a new ticket/issue from a voice command",
+  execution: {
+    expectedDuration: "instant",
+    mode: "sync",
+    asyncAckMessage: "Creating your ticket now..."
+  },
+  triggers: [
+    {
+      type: "event",
+      event: "voice.action.requested",
+      where: { action: "create_ticket" }
+    }
+  ],
+  permissions: [
+    { kind: "storage:write", scope: "tickets" },
+    { kind: "event:emit", pattern: "ticket.created" }
+  ],
+  limits: {
+    maxRunMs: 1e4,
+    maxSteps: 5
+  },
+  entryStepId: "validate",
+  steps: [
+    {
+      id: "validate",
+      name: "Validate Input",
+      kind: "transform",
+      transforms: {
+        "input.title": "{{trigger.payload.params.title}}",
+        "input.description": "{{trigger.payload.params.description}}",
+        "input.priority": "{{trigger.payload.params.priority}}",
+        "input.projectId": "{{trigger.payload.params.projectId}}",
+        "input.labels": "{{trigger.payload.params.labels}}",
+        "input.userId": "{{trigger.payload.userId}}"
+      },
+      next: "create"
+    },
+    {
+      id: "create",
+      name: "Create Ticket",
+      kind: "task",
+      task: "voice.create-ticket",
+      input: {
+        title: "{{input.title}}",
+        description: "{{input.description}}",
+        priority: "{{input.priority}}",
+        projectId: "{{input.projectId}}",
+        labels: "{{input.labels}}",
+        userId: "{{input.userId}}"
+      },
+      saveAs: "ticket",
+      next: "emit"
+    },
+    {
+      id: "emit",
+      name: "Emit Ticket Created Event",
+      kind: "emit",
+      event: "ticket.created",
+      payload: {
+        ticketId: "{{ticket.id}}",
+        title: "{{ticket.title}}",
+        priority: "{{ticket.priority}}",
+        source: "voice",
+        userId: "{{input.userId}}"
+      },
+      next: "output"
+    },
+    {
+      id: "output",
+      name: "Prepare Output",
+      kind: "transform",
+      transforms: {
+        "output.success": true,
+        "output.ticketId": "{{ticket.id}}",
+        "output.title": "{{ticket.title}}",
+        "output.url": "{{ticket.url}}",
+        "output.message": "Ticket created successfully"
+      },
+      next: null
+    }
+  ],
+  outputs: {
+    onCompleted: [
+      {
+        event: "voice.action.completed",
+        payload: {
+          action: "create_ticket",
+          success: true,
+          result: "{{output}}"
+        }
+      }
+    ],
+    onFailed: [
+      {
+        event: "voice.action.failed",
+        payload: {
+          action: "create_ticket",
+          error: "{{error}}"
+        }
+      }
+    ]
+  },
+  tags: ["voice", "tickets", "instant"]
+};
+
+// src/voice/search-codebase.ts
+var voiceSearchCodebaseContract = {
+  schemaVersion: "codmir.contract.v1",
+  id: "voice.search-codebase",
+  version: "1.0.0",
+  title: "Search Codebase via Voice",
+  description: "Searches the codebase for specific patterns, functions, or files",
+  execution: {
+    expectedDuration: "quick",
+    mode: "sync",
+    syncThreshold: 15e3,
+    // 15 seconds max wait
+    asyncAckMessage: "Searching the codebase now..."
+  },
+  triggers: [
+    {
+      type: "event",
+      event: "voice.action.requested",
+      where: { action: "search_codebase" }
+    }
+  ],
+  permissions: [
+    { kind: "repo:read", scope: "*" },
+    { kind: "event:emit", pattern: "search.completed" }
+  ],
+  limits: {
+    maxRunMs: 3e4,
+    maxSteps: 5
+  },
+  entryStepId: "validate",
+  steps: [
+    {
+      id: "validate",
+      name: "Validate Input",
+      kind: "transform",
+      transforms: {
+        "input.query": "{{trigger.payload.params.query}}",
+        "input.fileTypes": "{{trigger.payload.params.file_types}}",
+        "input.pathFilter": "{{trigger.payload.params.path_filter}}",
+        "input.maxResults": "{{trigger.payload.params.max_results}}",
+        "input.userId": "{{trigger.payload.userId}}"
+      },
+      next: "search"
+    },
+    {
+      id: "search",
+      name: "Search Codebase",
+      kind: "task",
+      task: "voice.search-codebase",
+      input: {
+        query: "{{input.query}}",
+        fileTypes: "{{input.fileTypes}}",
+        pathFilter: "{{input.pathFilter}}",
+        maxResults: "{{input.maxResults}}"
+      },
+      saveAs: "searchResults",
+      next: "output"
+    },
+    {
+      id: "output",
+      name: "Prepare Output",
+      kind: "transform",
+      transforms: {
+        "output.success": true,
+        "output.query": "{{input.query}}",
+        "output.results": "{{searchResults.results}}",
+        "output.total": "{{searchResults.total}}",
+        "output.message": "Found {{searchResults.total}} results"
+      },
+      next: null
+    }
+  ],
+  outputs: {
+    onCompleted: [
+      {
+        event: "voice.action.completed",
+        payload: {
+          action: "search_codebase",
+          success: true,
+          result: "{{output}}"
+        }
+      }
+    ],
+    onFailed: [
+      {
+        event: "voice.action.failed",
+        payload: {
+          action: "search_codebase",
+          error: "{{error}}"
+        }
+      }
+    ]
+  },
+  tags: ["voice", "search", "code", "quick"]
+};
+
+// src/voice/deploy-preview.ts
+var voiceDeployPreviewContract = {
+  schemaVersion: "codmir.contract.v1",
+  id: "voice.deploy-preview",
+  version: "1.0.0",
+  title: "Deploy Preview via Voice",
+  description: "Deploys a preview environment for testing",
+  execution: {
+    expectedDuration: "long",
+    mode: "async",
+    interruptible: true,
+    asyncAckMessage: "I'll start the deployment. This may take a few minutes - I'll notify you when it's ready."
+  },
+  triggers: [
+    {
+      type: "event",
+      event: "voice.action.requested",
+      where: { action: "deploy_preview" }
+    }
+  ],
+  permissions: [
+    { kind: "http:request", domains: ["api.vercel.com", "api.netlify.com", "api.railway.app"] },
+    { kind: "repo:read", scope: "*" },
+    { kind: "event:emit", pattern: "deploy.*" }
+  ],
+  limits: {
+    maxRunMs: 6e5,
+    // 10 minutes
+    maxSteps: 10
+  },
+  entryStepId: "validate",
+  steps: [
+    {
+      id: "validate",
+      name: "Validate Input",
+      kind: "transform",
+      transforms: {
+        "input.branch": "{{trigger.payload.params.branch}}",
+        "input.environment": "{{trigger.payload.params.environment}}",
+        "input.projectId": "{{trigger.payload.params.projectId}}",
+        "input.userId": "{{trigger.payload.userId}}"
+      },
+      next: "confirm"
+    },
+    {
+      id: "confirm",
+      name: "Confirm Deployment",
+      kind: "approval",
+      prompt: "Deploy branch '{{input.branch}}' to {{input.environment}} environment?",
+      approvers: ["{{input.userId}}"],
+      nextOnApproved: "deploy",
+      nextOnDenied: "cancelled",
+      timeout: { ms: 6e4 },
+      timeoutAction: "deny",
+      context: {
+        branch: "{{input.branch}}",
+        environment: "{{input.environment}}"
+      }
+    },
+    {
+      id: "deploy",
+      name: "Deploy to Preview",
+      kind: "task",
+      task: "voice.deploy-preview",
+      input: {
+        branch: "{{input.branch}}",
+        environment: "{{input.environment}}",
+        projectId: "{{input.projectId}}"
+      },
+      saveAs: "deployment",
+      timeout: { ms: 3e5 },
+      // 5 min timeout for deployment
+      next: "notify"
+    },
+    {
+      id: "notify",
+      name: "Emit Deployment Event",
+      kind: "emit",
+      event: "deploy.completed",
+      payload: {
+        deploymentId: "{{deployment.id}}",
+        url: "{{deployment.url}}",
+        branch: "{{input.branch}}",
+        environment: "{{input.environment}}",
+        source: "voice",
+        userId: "{{input.userId}}"
+      },
+      next: "output"
+    },
+    {
+      id: "output",
+      name: "Prepare Output",
+      kind: "transform",
+      transforms: {
+        "output.success": true,
+        "output.deploymentId": "{{deployment.id}}",
+        "output.url": "{{deployment.url}}",
+        "output.branch": "{{input.branch}}",
+        "output.message": "Deployment complete! Preview available at {{deployment.url}}"
+      },
+      next: null
+    },
+    {
+      id: "cancelled",
+      name: "Handle Cancellation",
+      kind: "transform",
+      transforms: {
+        "output.success": false,
+        "output.message": "Deployment was cancelled"
+      },
+      next: null
+    }
+  ],
+  outputs: {
+    onCompleted: [
+      {
+        event: "voice.action.completed",
+        payload: {
+          action: "deploy_preview",
+          success: true,
+          result: "{{output}}"
+        }
+      }
+    ],
+    onFailed: [
+      {
+        event: "voice.action.failed",
+        payload: {
+          action: "deploy_preview",
+          error: "{{error}}"
+        }
+      }
+    ],
+    onCancelled: [
+      {
+        event: "voice.action.cancelled",
+        payload: {
+          action: "deploy_preview",
+          reason: "User cancelled or approval timeout"
+        }
+      }
+    ]
+  },
+  tags: ["voice", "deploy", "preview", "long", "approval"]
+};
+
+// src/voice/save-note.ts
+var voiceSaveNoteContract = {
+  schemaVersion: "codmir.contract.v1",
+  id: "voice.save-note",
+  version: "1.0.0",
+  title: "Save Note via Voice",
+  description: "Saves a note or snippet for later reference",
+  execution: {
+    expectedDuration: "instant",
+    mode: "sync",
+    asyncAckMessage: "Saving your note..."
+  },
+  triggers: [
+    {
+      type: "event",
+      event: "voice.action.requested",
+      where: { action: "save_note" }
+    }
+  ],
+  permissions: [
+    { kind: "storage:write", scope: "notes" },
+    { kind: "event:emit", pattern: "note.saved" }
+  ],
+  limits: {
+    maxRunMs: 1e4,
+    maxSteps: 4
+  },
+  entryStepId: "validate",
+  steps: [
+    {
+      id: "validate",
+      name: "Validate Input",
+      kind: "transform",
+      transforms: {
+        "input.content": "{{trigger.payload.params.content}}",
+        "input.title": "{{trigger.payload.params.title}}",
+        "input.tags": "{{trigger.payload.params.tags}}",
+        "input.userId": "{{trigger.payload.userId}}"
+      },
+      next: "save"
+    },
+    {
+      id: "save",
+      name: "Save Note",
+      kind: "task",
+      task: "voice.save-note",
+      input: {
+        content: "{{input.content}}",
+        title: "{{input.title}}",
+        tags: "{{input.tags}}",
+        userId: "{{input.userId}}"
+      },
+      saveAs: "note",
+      next: "output"
+    },
+    {
+      id: "output",
+      name: "Prepare Output",
+      kind: "transform",
+      transforms: {
+        "output.success": true,
+        "output.noteId": "{{note.id}}",
+        "output.title": "{{note.title}}",
+        "output.message": "Note saved successfully"
+      },
+      next: null
+    }
+  ],
+  outputs: {
+    onCompleted: [
+      {
+        event: "voice.action.completed",
+        payload: {
+          action: "save_note",
+          success: true,
+          result: "{{output}}"
+        }
+      }
+    ],
+    onFailed: [
+      {
+        event: "voice.action.failed",
+        payload: {
+          action: "save_note",
+          error: "{{error}}"
+        }
+      }
+    ]
+  },
+  tags: ["voice", "notes", "instant"]
+};
+
+// src/voice/registry.ts
+var ACTION_TO_CONTRACT_ID = {
+  create_ticket: "voice.create-ticket",
+  update_ticket: "voice.update-ticket",
+  search_codebase: "voice.search-codebase",
+  search_documentation: "voice.search-documentation",
+  analyze_code: "voice.analyze-code",
+  suggest_fix: "voice.suggest-fix",
+  run_query: "voice.run-query",
+  get_metrics: "voice.get-metrics",
+  deploy_preview: "voice.deploy-preview",
+  check_deploy_status: "voice.check-deploy-status",
+  send_notification: "voice.send-notification",
+  create_summary: "voice.create-summary",
+  set_reminder: "voice.set-reminder",
+  save_note: "voice.save-note"
+};
+var VOICE_CONTRACTS = {
+  "voice.create-ticket": voiceCreateTicketContract,
+  "voice.search-codebase": voiceSearchCodebaseContract,
+  "voice.deploy-preview": voiceDeployPreviewContract,
+  "voice.save-note": voiceSaveNoteContract
+};
+function getVoiceContract(contractId) {
+  return VOICE_CONTRACTS[contractId];
+}
+function getVoiceContractForAction(actionName) {
+  const contractId = ACTION_TO_CONTRACT_ID[actionName];
+  if (!contractId) return void 0;
+  return VOICE_CONTRACTS[contractId];
+}
+
+exports.ContractValidationError = ContractValidationError;
+exports.DEFAULT_GRACE_EXTENSIONS = DEFAULT_GRACE_EXTENSIONS;
+exports.DURATION_SYNC_THRESHOLDS = DURATION_SYNC_THRESHOLDS;
+exports.GRACE_PRINCIPLES = GRACE_PRINCIPLES;
+exports.VOICE_CONTRACTS = VOICE_CONTRACTS;
+exports.and = and;
+exports.calculateRiskScore = calculateRiskScore;
+exports.cloneJson = cloneJson;
+exports.codeReviewContract = codeReviewContract;
+exports.contains = contains;
+exports.deepMergeJson = deepMergeJson;
+exports.deleteByPath = deleteByPath;
+exports.endsWith = endsWith;
+exports.eq = eq;
+exports.evalCondition = evalCondition;
+exports.exists = exists;
+exports.extractTemplatePath = extractTemplatePath;
+exports.getByPath = getByPath;
+exports.getVoiceContract = getVoiceContract;
+exports.getVoiceContractForAction = getVoiceContractForAction;
+exports.gt = gt;
+exports.gte = gte;
+exports.hasPermission = hasPermission;
+exports.isTemplate = isTemplate;
+exports.lt = lt;
+exports.lte = lte;
+exports.mergeJson = mergeJson;
+exports.neq = neq;
+exports.not = not;
+exports.or = or;
+exports.prAnalysisContract = prAnalysisContract;
+exports.prAnalysisWithLlmContract = prAnalysisWithLlmContract;
+exports.requiresHumanReview = requiresHumanReview;
+exports.resolveStepInput = resolveStepInput;
+exports.resolveTemplates = resolveTemplates;
+exports.setByPath = setByPath;
+exports.startsWith = startsWith;
+exports.ticketTriageContract = ticketTriageContract;
+exports.validateCondition = validateCondition;
+exports.validateContract = validateContract;
+exports.validateContractSafe = validateContractSafe;
+exports.voiceCreateTicketContract = voiceCreateTicketContract;
+exports.voiceDeployPreviewContract = voiceDeployPreviewContract;
+exports.voiceSaveNoteContract = voiceSaveNoteContract;
+exports.voiceSearchCodebaseContract = voiceSearchCodebaseContract;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map