@contractspec/lib.contracts 1.61.0 → 1.63.0

package/dist/llm/index.js

@@ -1,1715 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// src/registry-utils.ts
-var exports_registry_utils = {};
-__export(exports_registry_utils, {
-  groupByToArray: () => groupByToArray,
-  groupByMultiple: () => groupByMultiple,
-  groupBy: () => groupBy,
-  getUniqueTags: () => getUniqueTags,
-  getUniqueOwners: () => getUniqueOwners,
-  getUniqueDomains: () => getUniqueDomains,
-  filterBy: () => filterBy,
-  GroupingStrategies: () => GroupingStrategies
-});
-function filterBy(items, filter) {
-  return items.filter((item) => {
-    if (filter.tags?.length) {
-      const hasMatchingTag = filter.tags.some((tag) => item.meta.tags?.includes(tag));
-      if (!hasMatchingTag)
-        return false;
-    }
-    if (filter.owners?.length) {
-      const hasMatchingOwner = filter.owners.some((owner) => item.meta.owners?.includes(owner));
-      if (!hasMatchingOwner)
-        return false;
-    }
-    if (filter.stability?.length) {
-      if (!filter.stability.includes(item.meta.stability ?? "stable")) {
-        return false;
-      }
-    }
-    if (filter.domain) {
-      const itemDomain = GroupingStrategies.byDomain(item);
-      if (itemDomain !== filter.domain)
-        return false;
-    }
-    if (filter.keyPattern) {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      const pattern = filter.keyPattern.replace(/\*/g, ".*").replace(/\?/g, ".");
-      const regex = new RegExp(`^${pattern}$`, "i");
-      if (!regex.test(name))
-        return false;
-    }
-    return true;
-  });
-}
-function groupBy(items, keyFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const key = keyFn(item);
-    const existing = groups.get(key);
-    if (existing) {
-      existing.push(item);
-    } else {
-      groups.set(key, [item]);
-    }
-  }
-  return groups;
-}
-function groupByToArray(items, keyFn) {
-  const map = groupBy(items, keyFn);
-  return Array.from(map.entries()).map(([key, items2]) => ({ key, items: items2 }));
-}
-function groupByMultiple(items, keysFn) {
-  const groups = new Map;
-  for (const item of items) {
-    const keys = keysFn(item);
-    for (const key of keys) {
-      const existing = groups.get(key);
-      if (existing) {
-        existing.push(item);
-      } else {
-        groups.set(key, [item]);
-      }
-    }
-  }
-  return groups;
-}
-function getUniqueTags(items) {
-  const tags = new Set;
-  for (const item of items) {
-    for (const tag of item.meta.tags ?? []) {
-      tags.add(tag);
-    }
-  }
-  return Array.from(tags).sort();
-}
-function getUniqueOwners(items) {
-  const owners = new Set;
-  for (const item of items) {
-    for (const owner of item.meta.owners ?? []) {
-      owners.add(owner);
-    }
-  }
-  return Array.from(owners).sort();
-}
-function getUniqueDomains(items) {
-  const domains = new Set;
-  for (const item of items) {
-    domains.add(GroupingStrategies.byDomain(item));
-  }
-  return Array.from(domains).sort();
-}
-var GroupingStrategies;
-var init_registry_utils = __esm(() => {
-  GroupingStrategies = {
-    byTag: (item) => item.meta.tags?.[0] ?? "untagged",
-    byAllTags: (item) => item.meta.tags?.length ? item.meta.tags : ["untagged"],
-    byOwner: (item) => item.meta.owners?.[0] ?? "unowned",
-    byDomain: (item) => {
-      const name = item.meta.key ?? item.meta.key ?? "";
-      return name.split(".")[0] ?? "default";
-    },
-    byStability: (item) => item.meta.stability ?? "stable",
-    byUrlPath: (level) => (item) => {
-      if (!item.path)
-        return "root";
-      const segments = item.path.split("/").filter(Boolean);
-      return segments.slice(0, level).join("/") || "root";
-    }
-  };
-});
-
-// src/ownership.ts
-var StabilityEnum = {
-  Idea: "idea",
-  InCreation: "in_creation",
-  Experimental: "experimental",
-  Beta: "beta",
-  Stable: "stable",
-  Deprecated: "deprecated"
-};
-var OwnersEnum = {
-  PlatformCore: "platform.core",
-  PlatformSigil: "platform.sigil",
-  PlatformMarketplace: "platform.marketplace",
-  PlatformMessaging: "platform.messaging",
-  PlatformContent: "platform.content",
-  PlatformFeatureFlags: "platform.featureflags",
-  PlatformFinance: "platform.finance"
-};
-var Owners = OwnersEnum;
-var TagsEnum = {
-  Spots: "spots",
-  Collectivity: "collectivity",
-  Marketplace: "marketplace",
-  Sellers: "sellers",
-  Auth: "auth",
-  Login: "login",
-  Signup: "signup",
-  Guide: "guide",
-  Docs: "docs",
-  I18n: "i18n",
-  Incident: "incident",
-  Automation: "automation",
-  Hygiene: "hygiene"
-};
-var Tags = TagsEnum;
-
-// src/operations/operation.ts
-var isEmitDeclRef = (e) => ("ref" in e);
-var defineCommand = (spec) => ({
-  ...spec,
-  meta: { ...spec.meta, kind: "command" },
-  policy: {
-    ...spec.policy,
-    idempotent: spec.policy?.["policy"]?.idempotent ?? false
-  }
-});
-var defineQuery = (spec) => ({
-  ...spec,
-  meta: { ...spec.meta, kind: "query" },
-  policy: { ...spec.policy, idempotent: true }
-});
-
-// src/registry.ts
-init_registry_utils();
-import { compareVersions } from "compare-versions";
-var keyOfSpecContract = (spec) => `${spec.meta.key}.v${spec.meta.version}`;
-
-class SpecContractRegistry {
-  contractType;
-  items = new Map;
-  constructor(contractType, items) {
-    this.contractType = contractType;
-    if (items) {
-      items.forEach((p) => this.register(p));
-    }
-  }
-  register(p) {
-    const key = keyOfSpecContract(p);
-    if (this.items.has(key))
-      throw new Error(`Duplicate contract \`${this.contractType}\` ${key}`);
-    this.items.set(key, p);
-    return this;
-  }
-  count() {
-    return this.items.size;
-  }
-  list() {
-    return [...this.items.values()];
-  }
-  get(key, version) {
-    if (version != null)
-      return this.items.get(`${key}.v${version}`);
-    let candidate;
-    for (const [k, p] of this.items.entries()) {
-      if (!k.startsWith(`${key}.v`))
-        continue;
-      if (!candidate || compareVersions(p.meta.version, candidate.meta.version) > 0) {
-        candidate = p;
-      }
-    }
-    return candidate;
-  }
-  has(key, version) {
-    return !!this.get(key, version);
-  }
-  filter(criteria) {
-    return filterBy(this.list(), criteria);
-  }
-  listByTag(tag) {
-    return this.list().filter((p) => p.meta.tags?.includes(tag));
-  }
-  listByOwner(owner) {
-    return this.list().filter((p) => p.meta.owners?.includes(owner));
-  }
-  groupBy(keyFn) {
-    return groupBy(this.list(), keyFn);
-  }
-  getUniqueTags() {
-    return getUniqueTags(this.list());
-  }
-}
-
-// src/events.ts
-function defineEvent(e) {
-  return e;
-}
-var eventKey = (key, version) => `${key}.v${version}`;
-
-class EventRegistry extends SpecContractRegistry {
-  constructor(items) {
-    super("event", items);
-  }
-}
-
-// src/operations/registry.ts
-function opKey(key, version) {
-  return `${key}.v${version}`;
-}
-
-class OperationSpecRegistry extends SpecContractRegistry {
-  handlers = new Map;
-  constructor(items) {
-    super("operation", items);
-  }
-  bind(spec, handler) {
-    const key = opKey(spec.meta.key, spec.meta.version);
-    if (!this.items.has(key))
-      throw new Error(`Cannot bind; spec not found: ${key}`);
-    if (this.handlers.has(key))
-      throw new Error(`Handler already bound for ${key}`);
-    this.handlers.set(key, handler);
-    return this;
-  }
-  getHandler(key, version) {
-    const spec = this.get(key, version);
-    if (!spec)
-      return;
-    return this.handlers.get(opKey(spec.meta.key, spec.meta.version));
-  }
-  listBound() {
-    const out = [];
-    for (const [k, spec] of this.items.entries()) {
-      const h = this.handlers.get(k);
-      if (h)
-        out.push({ spec, handler: h });
-    }
-    return out;
-  }
-  async execute(key, version, rawInput, ctx) {
-    const baseSpec = this.get(key, version);
-    if (!baseSpec)
-      throw new Error(`Spec not found for ${key}${version ? `.v${version}` : ""}`);
-    const spec = await ctx.specVariantResolver?.resolve({
-      name: baseSpec.meta.key,
-      version: baseSpec.meta.version,
-      kind: baseSpec.meta.kind
-    }, ctx) ?? baseSpec;
-    let handlerKey = opKey(spec.meta.key, spec.meta.version);
-    let handler = this.handlers.get(handlerKey);
-    if (!handler) {
-      const fallbackKey = opKey(baseSpec.meta.key, baseSpec.meta.version);
-      handler = this.handlers.get(fallbackKey);
-      handlerKey = fallbackKey;
-    }
-    if (!handler)
-      throw new Error(`No handler bound for ${handlerKey}`);
-    const parsedInput = spec.io.input?.getZod().parse(rawInput);
-    if (ctx.decide) {
-      const [service, command] = spec.meta.key.split(".");
-      if (!service || !command)
-        throw new Error(`Invalid spec name: ${spec.meta.key}`);
-      const decision = await ctx.decide({
-        service,
-        command,
-        version: spec.meta.version,
-        actor: ctx.actor ?? "anonymous",
-        channel: ctx.channel,
-        roles: ctx.roles,
-        organizationId: ctx.organizationId,
-        userId: ctx.userId,
-        flags: []
-      });
-      if (decision.effect === "deny") {
-        throw new Error(`PolicyDenied: ${spec.meta.key}.v${spec.meta.version}`);
-      }
-      if (decision.rateLimit && ctx.rateLimit) {
-        const key2 = decision.rateLimit.key ?? "default";
-        const rpm = decision.rateLimit.rpm ?? 60;
-        await ctx.rateLimit(key2, 1, rpm);
-      }
-    }
-    const allowedEvents = new Map;
-    if (spec.sideEffects?.emits) {
-      for (const e of spec.sideEffects.emits) {
-        if (isEmitDeclRef(e)) {
-          const eventSpec = ctx.eventSpecResolver?.get(e.ref.key, e.ref.version);
-          if (eventSpec) {
-            allowedEvents.set(`${e.ref.key}.v${e.ref.version}`, eventSpec.payload);
-          }
-        } else {
-          allowedEvents.set(`${e.key}.v${e.version}`, e.payload);
-        }
-      }
-    }
-    const emitGuard = async (eventName, eventVersion, payload) => {
-      const key2 = eventKey(eventName, eventVersion);
-      const schema = allowedEvents.get(key2);
-      if (!schema)
-        throw new Error(`UndeclaredEvent: ${key2} not allowed by ${opKey(spec.meta.key, spec.meta.version)}`);
-      const parsed = schema.getZod().parse(payload);
-      await ctx.eventPublisher?.({
-        key: eventName,
-        version: eventVersion,
-        payload: parsed,
-        traceId: ctx.traceId
-      });
-    };
-    if (ctx.appConfig) {
-      if (!ctx.branding) {
-        ctx.branding = ctx.appConfig.branding;
-      }
-      if (!ctx.translation) {
-        ctx.translation = { config: ctx.appConfig.translation };
-      } else if (!ctx.translation.config) {
-        ctx.translation = {
-          ...ctx.translation,
-          config: ctx.appConfig.translation
-        };
-      }
-    }
-    const telemetryContext = ctx.telemetry;
-    const trackTelemetry = async (trigger, details) => {
-      if (!telemetryContext || !trigger?.event)
-        return;
-      try {
-        const props = trigger.properties?.(details) ?? {};
-        await telemetryContext.track(trigger.event.key, trigger.event.version ?? "1.0.0", props, {
-          tenantId: ctx.organizationId ?? undefined,
-          organizationId: ctx.organizationId,
-          userId: ctx.userId,
-          actor: ctx.actor,
-          channel: ctx.channel,
-          metadata: ctx.traceId ? { traceId: ctx.traceId } : undefined
-        });
-      } catch (_error) {}
-    };
-    let result;
-    try {
-      result = await handler(parsedInput, {
-        ...ctx,
-        __emitGuard__: emitGuard
-      });
-    } catch (error) {
-      if (spec.telemetry?.failure) {
-        await trackTelemetry(spec.telemetry.failure, {
-          input: parsedInput ?? rawInput,
-          error
-        });
-      }
-      throw error;
-    }
-    if (spec.telemetry?.success) {
-      await trackTelemetry(spec.telemetry.success, {
-        input: parsedInput ?? rawInput,
-        output: result
-      });
-    }
-    const outputModel = spec.io.output;
-    if (outputModel?.getZod) {
-      const parsedOutput = outputModel.getZod().parse(result);
-      return parsedOutput;
-    }
-    return result;
-  }
-}
-
-// src/operations/report/getContractVerificationStatus.ts
-import {
-  ScalarTypeEnum,
-  SchemaModel,
-  ZodSchemaType
-} from "@contractspec/lib.schema";
-import * as z from "zod";
-var REPORT_DOMAIN = "report";
-var REPORT_OWNERS = ["platform.core"];
-var REPORT_TAGS = ["report", "drift", "verification"];
-var REPORT_STABILITY = StabilityEnum.Experimental;
-var ContractVerificationStatusModel = new SchemaModel({
-  name: "ContractVerificationStatus",
-  fields: {
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    lastVerifiedSha: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    lastVerifiedDate: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: true
-    },
-    surfaces: {
-      type: ScalarTypeEnum.String_unsecure(),
-      isOptional: false,
-      isArray: true
-    },
-    driftMismatches: {
-      type: ScalarTypeEnum.Int_unsecure(),
-      isOptional: false
-    }
-  }
-});
-var GetContractVerificationStatusInput = new SchemaModel({
-  name: "GetContractVerificationStatusInput",
-  fields: {
-    projectPath: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    baseline: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
-  }
-});
-var GetContractVerificationStatusOutput = new ZodSchemaType(z.object({
-  contracts: z.object({
-    name: z.string(),
-    lastVerifiedSha: z.string().optional(),
-    lastVerifiedDate: z.string().optional(),
-    surfaces: z.string().array(),
-    driftMismatches: z.int()
-  }).array()
-}), {
-  name: "GetContractVerificationStatusOutput"
-});
-var GetContractVerificationStatusQuery = defineQuery({
-  meta: {
-    key: "report.getContractVerificationStatus",
-    title: "Get Contract Verification Status",
-    version: "1.0.0",
-    description: "Retrieves per-contract verification status for the impact report.",
-    goal: "Enable stakeholders to see contract health at a glance.",
-    context: "Part of the impact report domain. Reads from drift check outputs and verified.json to provide a consolidated view of each contract's drift debt and surface coverage.",
-    domain: REPORT_DOMAIN,
-    owners: REPORT_OWNERS,
-    tags: REPORT_TAGS,
-    stability: REPORT_STABILITY
-  },
-  io: {
-    input: GetContractVerificationStatusInput,
-    output: GetContractVerificationStatusOutput,
-    errors: {
-      PROJECT_NOT_FOUND: {
-        description: "Project path does not exist.",
-        http: 404,
-        when: "The provided projectPath does not resolve to a valid directory."
-      }
-    }
-  },
-  policy: {
-    auth: "anonymous",
-    pii: []
-  }
-});
-
-// src/install.ts
-function makeEmit(_spec, ctx) {
-  return {
-    ref: async (ev, payload) => {
-      await ctx.__emitGuard__?.(ev.meta.key, ev.meta.version, payload);
-    },
-    key: async (key, version, payload) => {
-      await ctx.__emitGuard__?.(key, version, payload);
-    },
-    object: async (evt) => {
-      await ctx.__emitGuard__?.(evt.key, evt.version, evt.payload);
-    }
-  };
-}
-function installOp(reg, spec, handler) {
-  return reg.register(spec).bind(spec, handler);
-}
-function op(spec, handler) {
-  return {
-    spec,
-    handler,
-    install: (reg) => installOp(reg, spec, handler)
-  };
-}
-
-// src/data-views/spec.ts
-function defineDataView(spec) {
-  return spec;
-}
-
-// src/data-views/report/contractVerificationTable.ts
-var ContractVerificationTableDataView = defineDataView({
-  meta: {
-    key: "report.contractVerificationTable",
-    title: "Contract Verification Table",
-    version: "1.0.0",
-    description: "Table view of per-contract verification status for the impact report.",
-    domain: "report",
-    owners: ["platform.core"],
-    tags: ["report", "data-view", "verification"],
-    stability: StabilityEnum.Experimental,
-    entity: "contract-verification"
-  },
-  source: {
-    primary: {
-      key: GetContractVerificationStatusQuery.meta.key,
-      version: GetContractVerificationStatusQuery.meta.version
-    }
-  },
-  view: {
-    kind: "table",
-    fields: [
-      {
-        key: "name",
-        label: "Contract / Endpoint / Event",
-        dataPath: "name"
-      },
-      {
-        key: "timeSinceVerified",
-        label: "Time since verified",
-        dataPath: "lastVerifiedDate"
-      },
-      {
-        key: "driftMismatches",
-        label: "Drift debt",
-        dataPath: "driftMismatches",
-        format: "number",
-        sortable: true
-      },
-      {
-        key: "surfaces",
-        label: "Surfaces covered",
-        dataPath: "surfaces",
-        format: "badge"
-      },
-      {
-        key: "lastVerifiedSha",
-        label: "Last verified commit",
-        dataPath: "lastVerifiedSha",
-        width: "sm"
-      }
-    ],
-    primaryField: "name",
-    secondaryFields: ["driftMismatches", "timeSinceVerified"],
-    columns: [
-      { field: "name", width: "lg" },
-      { field: "lastVerifiedSha", width: "sm" },
-      { field: "timeSinceVerified", width: "sm" },
-      { field: "surfaces", width: "md" },
-      { field: "driftMismatches", width: "xs", align: "right" }
-    ]
-  },
-  policy: {
-    flags: [],
-    pii: []
-  }
-});
-
-// src/operations/report/index.ts
-var getContractVerificationStatusHandler = async (input, _ctx) => {
-  try {
-    const cmdProcess = Bun.spawn(["contractspec", "impl", "status", "--format", "json", "--all"], {
-      cwd: input.projectPath
-    });
-    const cmdStdout = await cmdProcess.stdout;
-    const output = await Bun.readableStreamToText(cmdStdout);
-    if (!output) {
-      return { contracts: [] };
-    }
-    const cliOutput = JSON.parse(output);
-    const contracts = [];
-    for (const spec of cliOutput.results || []) {
-      const contract = {
-        name: spec.specKey,
-        lastVerifiedSha: spec.specHash,
-        lastVerifiedDate: spec.specHash ? new Date().toISOString() : undefined,
-        surfaces: spec.implementations.filter((impl) => impl.exists).map((impl) => impl.type),
-        driftMismatches: spec.implementations.filter((impl) => !impl.exists).length
-      };
-      contracts.push(contract);
-    }
-    return { contracts };
-  } catch (error) {
-    console.error("Failed to get contract verification status:", error);
-    return { contracts: [] };
-  }
-};
-function registerReportContracts(registry) {
-  installOp(registry, GetContractVerificationStatusQuery, getContractVerificationStatusHandler);
-  return registry;
-}
-// src/jsonschema.ts
-import z2 from "zod";
-function jsonSchemaForSpec(spec) {
-  return {
-    input: spec.io.input ? z2.toJSONSchema(spec.io.input.getZod()) : null,
-    output: spec.io.output ? z2.toJSONSchema(spec.io.output.getZod()) : null,
-    meta: {
-      name: spec.meta.key,
-      version: spec.meta.version,
-      kind: spec.meta.kind,
-      description: spec.meta.description,
-      tags: spec.meta.tags ?? [],
-      stability: spec.meta.stability ?? "stable"
-    }
-  };
-}
-function defaultRestPath(name, version) {
-  return `/${name.replace(/\./g, "/")}/v${version}`;
-}
-function sanitizeMcpName(name) {
-  const sanitized = name.replace(/\./g, "_");
-  return sanitized.slice(0, 64);
-}
-function defaultMcpTool(name, version) {
-  const safeName = name.replace(/\./g, "_");
-  const safeVersion = version.replace(/\./g, "_");
-  return `${safeName}-v${safeVersion}`;
-}
-function defaultMcpPrompt(key) {
-  return sanitizeMcpName(key);
-}
-function defaultGqlField(name, version) {
-  return `${name.replace(/\./g, "_")}_v${version}`;
-}
-
-// src/llm/exporters.ts
-var DEFAULT_SPEC_OPTIONS = {
-  format: "full",
-  includeSchemas: true,
-  includeScenarios: true,
-  includeExamples: true,
-  includePolicy: true,
-  includeSideEffects: true
-};
-var DEFAULT_FEATURE_OPTIONS = {
-  ...DEFAULT_SPEC_OPTIONS,
-  includeRelatedSpecs: true,
-  includeRelatedEvents: true,
-  includeRelatedPresentations: true
-};
-function operationSpecToContextMarkdown(spec) {
-  const m = spec.meta;
-  const lines = [];
-  lines.push(`# ${m.key} (v${m.version})`);
-  lines.push("");
-  lines.push(`> ${m.description}`);
-  lines.push("");
-  lines.push(`**Type:** ${m.kind} | **Stability:** ${m.stability}`);
-  lines.push("");
-  lines.push("## Goal");
-  lines.push("");
-  lines.push(m.goal);
-  lines.push("");
-  lines.push("## Context");
-  lines.push("");
-  lines.push(m.context);
-  lines.push("");
-  if (spec.acceptance?.scenarios?.length) {
-    lines.push("## Acceptance Criteria");
-    lines.push("");
-    for (const s of spec.acceptance.scenarios) {
-      lines.push(`### ${s.key}`);
-      lines.push("");
-      lines.push("**Given:**");
-      for (const g of s.given)
-        lines.push(`- ${g}`);
-      lines.push("");
-      lines.push("**When:**");
-      for (const w of s.when)
-        lines.push(`- ${w}`);
-      lines.push("");
-      lines.push("**Then:**");
-      for (const t of s.then)
-        lines.push(`- ${t}`);
-      lines.push("");
-    }
-  }
-  return lines.join(`
-`);
-}
-function operationSpecToFullMarkdown(spec, options = {}) {
-  const opts = { ...DEFAULT_SPEC_OPTIONS, ...options };
-  const m = spec.meta;
-  const lines = [];
-  lines.push(`# ${m.key}.v${m.version}`);
-  lines.push("");
-  lines.push(`> ${m.description}`);
-  lines.push("");
-  lines.push("## Metadata");
-  lines.push("");
-  lines.push("| Field | Value |");
-  lines.push("|-------|-------|");
-  lines.push(`| Kind | ${m.kind} |`);
-  lines.push(`| Stability | ${m.stability} |`);
-  lines.push(`| Owners | ${m.owners.join(", ")} |`);
-  lines.push(`| Tags | ${m.tags.join(", ")} |`);
-  lines.push("");
-  lines.push("## Goal");
-  lines.push("");
-  lines.push(m.goal);
-  lines.push("");
-  lines.push("## Context");
-  lines.push("");
-  lines.push(m.context);
-  lines.push("");
-  if (opts.includeSchemas) {
-    lines.push("## Input/Output");
-    lines.push("");
-    if (spec.io.input) {
-      lines.push("### Input Schema");
-      lines.push("");
-      lines.push("```json");
-      try {
-        const schema = jsonSchemaForSpec(spec);
-        lines.push(JSON.stringify(schema.input ?? {}, null, 2));
-      } catch {
-        lines.push("// Schema generation not available");
-      }
-      lines.push("```");
-      lines.push("");
-    }
-    lines.push("### Output Schema");
-    lines.push("");
-    lines.push("```json");
-    try {
-      const schema = jsonSchemaForSpec(spec);
-      lines.push(JSON.stringify(schema.output ?? {}, null, 2));
-    } catch {
-      lines.push("// Schema generation not available");
-    }
-    lines.push("```");
-    lines.push("");
-    if (spec.io.errors && Object.keys(spec.io.errors).length) {
-      lines.push("### Error Codes");
-      lines.push("");
-      lines.push("| Code | HTTP | Description | When |");
-      lines.push("|------|------|-------------|------|");
-      for (const [code, err] of Object.entries(spec.io.errors)) {
-        lines.push(`| \`${code}\` | ${err.http ?? 400} | ${err.description} | ${err.when} |`);
-      }
-      lines.push("");
-    }
-  }
-  if (opts.includePolicy) {
-    lines.push("## Policy");
-    lines.push("");
-    lines.push(`- **Auth Required:** ${spec.policy.auth}`);
-    lines.push(`- **Idempotent:** ${spec.policy.idempotent ?? m.kind === "query"}`);
-    if (spec.policy.rateLimit) {
-      lines.push(`- **Rate Limit:** ${spec.policy.rateLimit.rpm} rpm per ${spec.policy.rateLimit.key}`);
-    }
-    if (spec.policy.flags?.length) {
-      lines.push(`- **Feature Flags:** ${spec.policy.flags.join(", ")}`);
-    }
-    if (spec.policy.pii?.length) {
-      lines.push(`- **PII Fields:** ${spec.policy.pii.join(", ")}`);
-    }
-    if (spec.policy.escalate) {
-      lines.push(`- **Escalation:** ${spec.policy.escalate}`);
-    }
-    lines.push("");
-  }
-  if (opts.includeSideEffects && spec.sideEffects) {
-    if (spec.sideEffects.emits?.length) {
-      lines.push("## Events Emitted");
-      lines.push("");
-      for (const e of spec.sideEffects.emits) {
-        if (isEmitDeclRef(e)) {
-          lines.push(`- \`${e.ref.key}.v${e.ref.version}\` \u2014 ${e.when}`);
-        } else {
-          lines.push(`- \`${e.key}.v${e.version}\` \u2014 ${e.when}`);
-        }
-      }
-      lines.push("");
-    }
-    if (spec.sideEffects.analytics?.length) {
-      lines.push("## Analytics Events");
-      lines.push("");
-      for (const a of spec.sideEffects.analytics) {
-        lines.push(`- ${a}`);
-      }
-      lines.push("");
-    }
-  }
-  if (opts.includeScenarios && spec.acceptance?.scenarios?.length) {
-    lines.push("## Acceptance Scenarios");
-    lines.push("");
-    for (const s of spec.acceptance.scenarios) {
-      lines.push(`### ${s.key}`);
-      lines.push("");
-      lines.push("**Given:**");
-      for (const g of s.given)
-        lines.push(`- ${g}`);
-      lines.push("");
-      lines.push("**When:**");
-      for (const w of s.when)
-        lines.push(`- ${w}`);
-      lines.push("");
-      lines.push("**Then:**");
-      for (const t of s.then)
-        lines.push(`- ${t}`);
-      lines.push("");
-    }
-  }
-  if (opts.includeExamples && spec.acceptance?.examples?.length) {
-    lines.push("## Examples");
-    lines.push("");
-    for (const ex of spec.acceptance.examples) {
-      lines.push(`### ${ex.key}`);
-      lines.push("");
-      lines.push("**Input:**");
-      lines.push("```json");
-      lines.push(JSON.stringify(ex.input, null, 2));
-      lines.push("```");
-      lines.push("");
-      lines.push("**Output:**");
-      lines.push("```json");
-      lines.push(JSON.stringify(ex.output, null, 2));
-      lines.push("```");
-      lines.push("");
-    }
-  }
-  if (spec.transport) {
-    lines.push("## Transport Configuration");
-    lines.push("");
-    if (spec.transport.rest) {
-      lines.push(`- **REST:** ${spec.transport.rest.method ?? "POST"} ${spec.transport.rest.path ?? "auto"}`);
-    }
-    if (spec.transport.gql) {
-      lines.push(`- **GraphQL:** ${spec.transport.gql.field ?? "auto"}`);
-    }
-    if (spec.transport.mcp) {
-      lines.push(`- **MCP Tool:** ${spec.transport.mcp.toolName ?? "auto"}`);
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-function operationSpecToAgentPrompt(spec, options) {
-  const taskType = options?.taskType ?? "implement";
-  const m = spec.meta;
-  const lines = [];
-  const taskVerb = {
-    implement: "Implement",
-    test: "Write tests for",
-    refactor: "Refactor",
-    review: "Review"
-  }[taskType];
-  lines.push(`# Task: ${taskVerb} ${m.key}.v${m.version}`);
-  lines.push("");
-  lines.push("## Context");
-  lines.push("");
-  lines.push(`You are working on a ContractSpec-driven codebase. This spec defines a ${m.kind} operation.`);
-  lines.push("");
-  lines.push(`**Goal:** ${m.goal}`);
-  lines.push("");
-  lines.push(`**Background:** ${m.context}`);
-  lines.push("");
-  lines.push("## Specification");
-  lines.push("");
-  lines.push(operationSpecToFullMarkdown(spec));
-  lines.push("");
-  lines.push("## Instructions");
-  lines.push("");
-  if (taskType === "implement") {
-    lines.push("Implement this specification following these requirements:");
-    lines.push("");
-    lines.push("1. **Type Safety**: Use TypeScript with strict typing. No `any` types.");
-    lines.push("2. **Input Validation**: Validate input against the schema before processing.");
-    lines.push("3. **Error Handling**: Implement all error cases defined in the spec.");
-    lines.push("4. **Events**: Emit events as specified in sideEffects.emits.");
-    lines.push("5. **Policy**: Respect auth, rate limits, and feature flags.");
-    lines.push("6. **Idempotency**: " + (spec.policy.idempotent ? "This operation MUST be idempotent." : "This operation may have side effects."));
-    lines.push("");
-    if (spec.policy.pii?.length) {
-      lines.push("**PII Handling**: The following fields contain PII and must be handled carefully:");
-      for (const field of spec.policy.pii) {
-        lines.push(`- ${field}`);
-      }
-      lines.push("");
-    }
-  } else if (taskType === "test") {
-    lines.push("Write comprehensive tests for this specification:");
-    lines.push("");
-    lines.push("1. Test all acceptance scenarios defined in the spec.");
-    lines.push("2. Test all error cases with appropriate assertions.");
-    lines.push("3. Test edge cases and boundary conditions.");
-    lines.push("4. Verify events are emitted correctly.");
-    lines.push('5. Use descriptive test names following the pattern: "should [behavior] when [condition]"');
-    lines.push("");
-  } else if (taskType === "refactor") {
-    lines.push("Refactor this implementation while preserving all behavior:");
-    lines.push("");
-    lines.push("1. Maintain compliance with the specification.");
-    lines.push("2. Improve code clarity and maintainability.");
-    lines.push("3. Reduce complexity where possible.");
-    lines.push("4. Ensure all existing tests still pass.");
-    lines.push("");
-  } else if (taskType === "review") {
-    lines.push("Review this implementation against the specification:");
-    lines.push("");
-    lines.push("1. Verify input/output types match the schema.");
-    lines.push("2. Check all error cases are handled.");
-    lines.push("3. Verify events are emitted as specified.");
-    lines.push("4. Check policy compliance (auth, rate limits).");
-    lines.push("5. Report any deviations from the spec.");
-    lines.push("");
-  }
-  if (options?.existingCode) {
-    lines.push("## Existing Code");
-    lines.push("");
-    lines.push("```typescript");
-    lines.push(options.existingCode);
-    lines.push("```");
-    lines.push("");
-  }
-  lines.push("## Expected Output");
-  lines.push("");
-  if (taskType === "implement" || taskType === "refactor") {
-    lines.push("Provide a complete TypeScript implementation. Include:");
-    lines.push("- Type definitions for input/output");
-    lines.push("- Handler function with proper error handling");
-    lines.push("- JSDoc comments explaining the implementation");
-  } else if (taskType === "test") {
-    lines.push("Provide a complete test file using the testing framework available (prefer Vitest).");
-  } else if (taskType === "review") {
-    lines.push("Provide a structured review with:");
-    lines.push("- Compliance status (pass/fail for each requirement)");
-    lines.push("- Issues found with severity (error/warning/info)");
-    lines.push("- Suggestions for improvement");
-  }
-  lines.push("");
-  return lines.join(`
-`);
-}
-function featureToMarkdown(feature, deps, options = {}) {
-  const opts = { ...DEFAULT_FEATURE_OPTIONS, ...options };
-  const m = feature.meta;
-  const lines = [];
-  lines.push(`# Feature: ${m.title ?? m.key}`);
-  lines.push("");
-  if (m.description) {
-    lines.push(`> ${m.description}`);
-    lines.push("");
-  }
-  lines.push("## Overview");
-  lines.push("");
-  lines.push(`- **Key:** \`${m.key}\``);
-  lines.push(`- **Stability:** ${m.stability}`);
-  lines.push(`- **Owners:** ${m.owners.join(", ")}`);
-  if (m.tags?.length) {
-    lines.push(`- **Tags:** ${m.tags.join(", ")}`);
-  }
-  lines.push("");
-  if (feature.operations?.length) {
-    lines.push("## Operations");
-    lines.push("");
-    lines.push("| Name | Version | Type |");
-    lines.push("|------|---------|------|");
-    for (const op2 of feature.operations) {
-      const spec = deps?.specs?.get(op2.key, op2.version);
-      const kind = spec?.meta.kind ?? "unknown";
-      lines.push(`| ${op2.key} | v${op2.version} | ${kind} |`);
-    }
-    lines.push("");
-    if (opts.includeRelatedSpecs && deps?.specs) {
-      lines.push("### Operation Details");
-      lines.push("");
-      for (const op2 of feature.operations) {
-        const spec = deps.specs.get(op2.key, op2.version);
-        if (spec) {
-          lines.push(`---`);
-          lines.push("");
-          lines.push(operationSpecToFullMarkdown(spec, opts));
-        }
-      }
-    }
-  }
-  if (feature.events?.length) {
-    lines.push("## Events");
-    lines.push("");
-    lines.push("| Name | Version |");
-    lines.push("|------|---------|");
-    for (const evt of feature.events) {
-      lines.push(`| ${evt.key} | v${evt.version} |`);
-    }
-    lines.push("");
-  }
-  if (feature.presentations?.length) {
-    lines.push("## Presentations");
-    lines.push("");
-    lines.push("| Name | Version |");
-    lines.push("|------|---------|");
-    for (const pres of feature.presentations) {
-      lines.push(`| ${pres.key} | v${pres.version} |`);
-    }
-    lines.push("");
-    if (opts.includeRelatedPresentations && deps?.presentations) {
-      lines.push("### Presentation Details");
-      lines.push("");
-      for (const pres of feature.presentations) {
-        const p = deps.presentations.get(pres.key, pres.version);
-        if (p) {
-          lines.push(`#### ${pres.key}.v${pres.version}`);
-          lines.push("");
-          lines.push(`- **Type:** ${p.source.type}`);
-          if (p.source.type === "component") {
-            lines.push(`- **Component:** ${p.source.componentKey}`);
-          }
-          lines.push("");
-        }
-      }
-    }
-  }
-  if (feature.capabilities) {
-    if (feature.capabilities.provides?.length) {
-      lines.push("## Capabilities Provided");
-      lines.push("");
-      for (const cap of feature.capabilities.provides) {
-        lines.push(`- \`${cap.key}.v${cap.version}\``);
-      }
-      lines.push("");
-    }
-    if (feature.capabilities.requires?.length) {
-      lines.push("## Capabilities Required");
-      lines.push("");
-      for (const cap of feature.capabilities.requires) {
-        lines.push(`- \`${cap.key}\`${cap.version ? `.v${cap.version}` : ""} (${cap.optional ? "optional" : "required"})`);
-      }
-      lines.push("");
-    }
-  }
-  return lines.join(`
-`);
-}
-function presentationToMarkdown(presentation) {
-  const m = presentation.meta;
-  const lines = [];
-  lines.push(`# Presentation: ${m.key}.v${m.version}`);
-  lines.push("");
-  if (m.description) {
-    lines.push(`> ${m.description}`);
-    lines.push("");
-  }
-  lines.push("## Metadata");
-  lines.push("");
-  lines.push(`- **Name:** ${m.key}`);
-  lines.push(`- **Version:** ${m.version}`);
-  if (m.stability)
-    lines.push(`- **Stability:** ${m.stability}`);
-  if (m.owners?.length)
-    lines.push(`- **Owners:** ${m.owners.join(", ")}`);
-  if (m.tags?.length)
-    lines.push(`- **Tags:** ${m.tags.join(", ")}`);
-  lines.push("");
-  lines.push("## Source");
-  lines.push("");
-  lines.push(`- **Type:** ${presentation.source.type}`);
-  if (presentation.source.type === "component") {
-    lines.push(`- **Framework:** ${presentation.source.framework}`);
-    lines.push(`- **Component Key:** ${presentation.source.componentKey}`);
-  }
-  lines.push("");
-  lines.push("## Supported Targets");
-  lines.push("");
-  for (const target of presentation.targets) {
-    lines.push(`- ${target}`);
-  }
-  lines.push("");
-  if (presentation.policy) {
-    lines.push("## Policy");
-    lines.push("");
-    if (presentation.policy.flags?.length) {
-      lines.push(`- **Feature Flags:** ${presentation.policy.flags.join(", ")}`);
-    }
-    if (presentation.policy.pii?.length) {
-      lines.push(`- **PII Fields:** ${presentation.policy.pii.join(", ")}`);
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-function eventToMarkdown(event) {
-  const lines = [];
-  lines.push(`# Event: ${event.meta.key}.v${event.meta.version}`);
-  lines.push("");
-  lines.push("## Metadata");
-  lines.push("");
-  lines.push(`- **Name:** ${event.meta.key}`);
-  lines.push(`- **Version:** ${event.meta.version}`);
-  if (event.meta.description)
-    lines.push(`- **Description:** ${event.meta.description}`);
-  lines.push("");
-  lines.push("## Payload Schema");
-  lines.push("");
-  lines.push("```json");
-  try {
-    const zodSchema = event.payload.getZod();
-    if ("shape" in zodSchema && zodSchema.shape) {
-      const shape = zodSchema.shape;
-      const fields = Object.keys(shape);
-      lines.push(JSON.stringify({ fields }, null, 2));
-    } else {
-      lines.push("// Payload schema available at runtime");
-    }
-  } catch {
-    lines.push("// Schema details available at runtime");
-  }
-  lines.push("```");
-  lines.push("");
-  return lines.join(`
-`);
-}
-function docBlockToMarkdown(doc) {
-  const lines = [];
-  lines.push(`# ${doc.title}`);
-  lines.push("");
-  if (doc.summary) {
-    lines.push(`> ${doc.summary}`);
-    lines.push("");
-  }
-  lines.push("## Metadata");
-  lines.push("");
-  lines.push(`- **ID:** ${doc.id}`);
-  lines.push(`- **Kind:** ${doc.kind ?? "reference"}`);
-  lines.push(`- **Visibility:** ${doc.visibility ?? "public"}`);
-  if (doc.tags?.length)
-    lines.push(`- **Tags:** ${doc.tags.join(", ")}`);
-  if (doc.owners?.length)
-    lines.push(`- **Owners:** ${doc.owners.join(", ")}`);
-  if (doc.domain)
-    lines.push(`- **Domain:** ${doc.domain}`);
-  lines.push("");
-  lines.push("## Content");
-  lines.push("");
-  lines.push(doc.body);
-  lines.push("");
-  if (doc.links?.length) {
-    lines.push("## Related Links");
-    lines.push("");
-    for (const link of doc.links) {
-      lines.push(`- [${link.label}](${link.href})`);
-    }
-    lines.push("");
-  }
-  return lines.join(`
-`);
-}
-function exportSpec(spec, options = {}) {
-  const format = options.format ?? "full";
-  let markdown;
-  switch (format) {
-    case "context":
-      markdown = operationSpecToContextMarkdown(spec);
-      break;
-    case "prompt":
-      markdown = operationSpecToAgentPrompt(spec);
-      break;
-    case "full":
-    default:
-      markdown = operationSpecToFullMarkdown(spec, options);
-      break;
-  }
-  return {
-    spec,
-    markdown,
-    format,
-    meta: {
-      specName: spec.meta.key,
-      specVersion: spec.meta.version,
-      exportedAt: new Date().toISOString(),
-      wordCount: markdown.split(/\s+/).length
-    }
-  };
-}
-function exportFeature(feature, deps, options = {}) {
-  const format = options.format ?? "full";
-  const markdown = featureToMarkdown(feature, deps, options);
-  return {
-    feature,
-    markdown,
-    format,
-    includedSpecs: feature.operations?.map((o) => `${o.key}.v${o.version}`) ?? [],
-    includedEvents: feature.events?.map((e) => `${e.key}.v${e.version}`) ?? [],
-    includedPresentations: feature.presentations?.map((p) => `${p.key}.v${p.version}`) ?? []
-  };
-}
-
-// src/llm/prompts.ts
-var AGENT_SYSTEM_PROMPTS = {
-  "claude-code": `You are an expert TypeScript developer working with ContractSpec, a spec-first development framework.
-
-Your code follows these principles:
-- Type-safe with comprehensive TypeScript types (no \`any\`)
-- Well-documented with JSDoc comments
-- Production-ready with proper error handling
-- Following SOLID principles and clean code practices
-- Modular and testable
-
-When implementing specs:
-1. Validate input against the schema before processing
-2. Handle all error cases defined in the spec
-3. Emit events as specified in sideEffects
-4. Respect policy constraints (auth, rate limits, PII handling)
-5. Follow the acceptance scenarios as your implementation guide
-
-Generate clean, idiomatic TypeScript that exactly matches the specification.`,
-  "cursor-cli": `You are implementing features for a ContractSpec-driven codebase.
-
-ContractSpec is a spec-first framework where specifications define:
-- Operations (commands and queries) with typed I/O
-- Events that operations emit
-- Presentations for UI components
-- Features that group related specs
-
-When working with specs:
-- Read the spec carefully before implementing
-- Match the input/output types exactly
-- Implement all error cases
-- Follow the acceptance scenarios
-- Respect policy constraints
-
-Use the project's existing patterns and conventions.`,
-  "generic-mcp": `You are a code generation assistant working with ContractSpec specifications.
-
-ContractSpec specs define:
-- meta: name, version, kind (command/query), description, goal, context
-- io: input schema, output schema, error definitions
-- policy: auth level, rate limits, feature flags, PII handling
-- sideEffects: events to emit, analytics, audit
-- acceptance: scenarios and examples
-
-Your task is to generate or modify code that complies with the given specification.
-Follow the spec exactly and handle all defined cases.`
-};
-function generateImplementationPrompt(spec, agent, options) {
-  const systemPrompt = AGENT_SYSTEM_PROMPTS[agent];
-  const specMarkdown = operationSpecToFullMarkdown(spec);
-  let taskPrompt;
-  if (agent === "claude-code") {
-    taskPrompt = `## Implementation Task
-
-Implement the following ContractSpec operation:
-
-${specMarkdown}
-
-${options?.targetPath ? `**Target file:** \`${options.targetPath}\`
-` : ""}
-${options?.existingCode ? `**Existing code to modify:**
-\`\`\`typescript
-${options.existingCode}
-\`\`\`
-` : ""}
-
-Generate a complete, production-ready TypeScript implementation that:
-1. Exports a handler function matching the spec signature
-2. Validates input using the schema
-3. Handles all defined error cases
-4. Emits events as specified
-5. Includes JSDoc documentation
-
-Provide ONLY the TypeScript code.`;
-  } else if (agent === "cursor-cli") {
-    taskPrompt = `Implement this ContractSpec operation.
-
-${specMarkdown}
-
-${options?.targetPath ? `Target: ${options.targetPath}
-` : ""}
-
-Requirements:
-- TypeScript with strict types
-- Handle all error cases
-- Emit specified events
-- Follow acceptance scenarios`;
-  } else {
-    taskPrompt = operationSpecToAgentPrompt(spec, {
-      taskType: "implement",
-      existingCode: options?.existingCode
-    });
-  }
-  return {
-    agent,
-    systemPrompt,
-    taskPrompt
-  };
-}
-function generateTestPrompt(spec, agent, options) {
-  const framework = options?.testFramework ?? "vitest";
-  const specMarkdown = operationSpecToFullMarkdown(spec);
-  const taskPrompt = `## Test Generation Task
-
-Generate comprehensive tests for this specification:
-
-${specMarkdown}
-
-${options?.implementationCode ? `**Implementation:**
-\`\`\`typescript
-${options.implementationCode}
-\`\`\`
-` : ""}
-
-**Test Framework:** ${framework}
-
-Generate tests that:
-1. Cover all acceptance scenarios from the spec
-2. Test all defined error cases
-3. Verify input validation
-4. Check event emissions
-5. Test edge cases
-
-Use descriptive test names: "should [behavior] when [condition]"
-
-Provide a complete test file.`;
-  return {
-    agent,
-    systemPrompt: AGENT_SYSTEM_PROMPTS[agent],
-    taskPrompt
-  };
-}
-function generateReviewPrompt(spec, agent, implementationCode) {
-  const specMarkdown = operationSpecToFullMarkdown(spec);
-  const taskPrompt = `## Code Review Task
-
-Review this implementation against its specification:
-
-**Specification:**
-${specMarkdown}
-
-**Implementation:**
-\`\`\`typescript
-${implementationCode}
-\`\`\`
-
-Provide a structured review:
-
-### Compliance Check
-- [ ] Input types match spec
-- [ ] Output types match spec
-- [ ] All error cases handled
-- [ ] Events emitted correctly
-- [ ] Policy constraints respected
-
-### Issues Found
-List any issues with severity (error/warning/info)
-
-### Suggestions
-List improvements and recommendations
-
-Be thorough and precise. Focus on spec compliance first, then code quality.`;
-  return {
-    agent,
-    systemPrompt: AGENT_SYSTEM_PROMPTS[agent],
-    taskPrompt
-  };
-}
-function generateVerificationPrompt(spec, implementationCode) {
-  const specMarkdown = operationSpecToFullMarkdown(spec);
-  const taskPrompt = `## Semantic Verification Task
-
-Verify that this implementation fulfills the specification's intent.
-
-**Specification:**
-${specMarkdown}
-
-**Implementation:**
-\`\`\`typescript
-${implementationCode}
-\`\`\`
-
-Analyze and respond with JSON:
-
-\`\`\`json
-{
-  "passed": true/false,
-  "score": 0-100,
-  "compliance": {
-    "inputTypes": { "match": true/false, "issues": [] },
-    "outputTypes": { "match": true/false, "issues": [] },
-    "errorHandling": { "coverage": "full/partial/none", "missing": [] },
-    "eventEmission": { "correct": true/false, "issues": [] },
-    "policyCompliance": { "auth": true/false, "rateLimit": true/false, "pii": true/false }
-  },
-  "scenarios": [
-    { "name": "scenario name", "covered": true/false, "notes": "" }
-  ],
-  "issues": [
-    { "severity": "error/warning/info", "category": "type/export/import/scenario/error_handling/semantic", "message": "", "suggestion": "" }
-  ],
-  "summary": "Brief summary of verification results"
-}
-\`\`\``;
-  return {
-    agent: "generic-mcp",
-    taskPrompt
-  };
-}
-function generateImplementationPlan(spec, options) {
-  const m = spec.meta;
-  const fileStructure = [];
-  const basePath = options?.projectRoot ?? "src";
-  const specPath = m.key.replace(/\./g, "/");
-  if (m.kind === "command" || m.kind === "query") {
-    fileStructure.push({
-      path: `${basePath}/${specPath}/handler.ts`,
-      purpose: "Main handler implementation",
-      type: "create"
-    }, {
-      path: `${basePath}/${specPath}/types.ts`,
-      purpose: "Type definitions",
-      type: "create"
-    }, {
-      path: `${basePath}/${specPath}/handler.test.ts`,
-      purpose: "Handler tests",
-      type: "create"
-    });
-  }
-  const steps = [];
-  let order = 1;
-  steps.push({
-    order: order++,
-    title: "Define Types",
-    description: "Create TypeScript types for input, output, and internal data structures",
-    acceptanceCriteria: [
-      "Input type matches spec schema exactly",
-      "Output type matches spec schema exactly",
-      "Error types defined for all error cases"
-    ]
-  });
-  steps.push({
-    order: order++,
-    title: "Implement Input Validation",
-    description: "Add validation logic for the input payload",
-    acceptanceCriteria: [
-      "All required fields are validated",
-      "Type constraints are enforced",
-      "Validation errors return appropriate error codes"
-    ]
-  });
-  steps.push({
-    order: order++,
-    title: "Implement Core Logic",
-    description: "Implement the main business logic of the operation",
-    acceptanceCriteria: spec.acceptance?.scenarios?.map((s) => s.key) ?? [
-      "Operation completes successfully for valid input"
-    ]
-  });
-  if (spec.io.errors && Object.keys(spec.io.errors).length > 0) {
-    steps.push({
-      order: order++,
-      title: "Implement Error Handling",
-      description: "Handle all defined error cases",
-      acceptanceCriteria: Object.entries(spec.io.errors).map(([code, err]) => `Handle ${code}: ${err.when}`)
-    });
-  }
-  if (spec.sideEffects?.emits?.length) {
-    steps.push({
-      order: order++,
-      title: "Implement Event Emission",
-      description: "Emit events as specified",
-      acceptanceCriteria: spec.sideEffects.emits.map((e) => {
-        if ("ref" in e) {
-          return `Emit ${e.ref.key}.v${e.ref.version} when ${e.when}`;
-        }
-        return `Emit ${e.key}.v${e.version} when ${e.when}`;
-      })
-    });
-  }
-  steps.push({
-    order: order++,
-    title: "Write Tests",
-    description: "Create comprehensive test suite",
-    acceptanceCriteria: [
-      "All acceptance scenarios covered",
-      "All error cases tested",
-      "Edge cases handled",
-      "Events verified"
-    ]
-  });
-  const constraints = {
-    policy: [],
-    security: [],
-    pii: []
-  };
-  constraints.policy.push(`Auth level: ${spec.policy.auth}`);
-  if (spec.policy.idempotent !== undefined) {
-    constraints.policy.push(`Idempotent: ${spec.policy.idempotent}`);
-  }
-  if (spec.policy.rateLimit) {
-    constraints.policy.push(`Rate limit: ${spec.policy.rateLimit.rpm} rpm per ${spec.policy.rateLimit.key}`);
-  }
-  if (spec.policy.flags?.length) {
-    constraints.policy.push(`Feature flags required: ${spec.policy.flags.join(", ")}`);
-  }
-  if (spec.policy.escalate) {
-    constraints.security.push(`Escalation required: ${spec.policy.escalate}`);
-  }
-  if (spec.policy.pii?.length) {
-    constraints.pii = spec.policy.pii;
-  }
-  const verificationChecklist = [
-    "Input validation works for all cases",
-    "Output matches expected schema",
-    "All error cases return correct codes",
-    "Events are emitted with correct payloads",
-    "Auth requirements are enforced",
-    "Rate limiting is applied (if applicable)",
-    "PII fields are handled correctly",
-    "All acceptance scenarios pass",
-    "Tests provide adequate coverage"
-  ];
-  return {
-    target: {
-      type: "spec",
-      key: m.key,
-      version: m.version
-    },
-    context: {
-      goal: m.goal,
-      description: m.description,
-      background: m.context
-    },
-    specMarkdown: operationSpecToFullMarkdown(spec),
-    fileStructure,
-    steps,
-    constraints,
-    verificationChecklist
-  };
-}
-function formatPlanForAgent(plan, agent) {
-  let taskPrompt;
-  if (agent === "claude-code") {
-    taskPrompt = `## Implementation Plan: ${plan.target.key}.v${plan.target.version}
-
-### Context
-**Goal:** ${plan.context.goal}
-
-**Background:** ${plan.context.background}
-
-### Specification
-${plan.specMarkdown}
-
-### File Structure
-${plan.fileStructure.map((f) => `- \`${f.path}\` (${f.type}): ${f.purpose}`).join(`
-`)}
-
-### Implementation Steps
-${plan.steps.map((s) => `
-#### Step ${s.order}: ${s.title}
-${s.description}
-
-**Acceptance Criteria:**
-${s.acceptanceCriteria.map((c) => `- [ ] ${c}`).join(`
-`)}
-`).join(`
-`)}
-
-### Constraints
-${plan.constraints.policy.length ? `**Policy:**
-${plan.constraints.policy.map((p) => `- ${p}`).join(`
-`)}
-` : ""}
-${plan.constraints.security.length ? `**Security:**
-${plan.constraints.security.map((s) => `- ${s}`).join(`
-`)}
-` : ""}
-${plan.constraints.pii.length ? `**PII Handling:**
-${plan.constraints.pii.map((p) => `- ${p}`).join(`
-`)}
-` : ""}
-
-### Verification Checklist
-${plan.verificationChecklist.map((c) => `- [ ] ${c}`).join(`
-`)}
-
-Implement this plan step by step.`;
-  } else if (agent === "cursor-cli") {
-    taskPrompt = `# ${plan.target.key}.v${plan.target.version}
-
-${plan.context.goal}
-
-## Spec
-${plan.specMarkdown}
-
-## Files to create
-${plan.fileStructure.map((f) => `${f.type}: ${f.path}`).join(`
-`)}
-
-## Steps
-${plan.steps.map((s) => `${s.order}. ${s.title}`).join(`
-`)}`;
-  } else {
-    taskPrompt = `Implementation plan for ${plan.target.key}.v${plan.target.version}
-
-${plan.specMarkdown}
-
-Steps:
-${plan.steps.map((s) => `${s.order}. ${s.title}: ${s.description}`).join(`
-`)}`;
-  }
-  return {
-    agent,
-    systemPrompt: AGENT_SYSTEM_PROMPTS[agent],
-    taskPrompt
-  };
-}
-function generateFixViolationsPrompt(spec, implementationCode, violations) {
-  const specMarkdown = operationSpecToFullMarkdown(spec);
-  const violationsList = violations.map((v, i) => `${i + 1}. ${v.message}${v.suggestion ? `
-   Suggestion: ${v.suggestion}` : ""}`).join(`
-`);
-  const taskPrompt = `## Fix Specification Violations
-
-The following implementation has violations against its specification:
-
-**Specification:**
-${specMarkdown}
-
-**Current Implementation:**
-\`\`\`typescript
-${implementationCode}
-\`\`\`
-
-**Violations Found:**
-${violationsList}
-
-Fix ALL violations while maintaining existing functionality.
-Provide the corrected implementation.`;
-  return {
-    agent: "generic-mcp",
-    taskPrompt
-  };
-}
-export {
-  presentationToMarkdown,
-  operationSpecToFullMarkdown,
-  operationSpecToContextMarkdown,
-  operationSpecToAgentPrompt,
-  generateVerificationPrompt,
-  generateTestPrompt,
-  generateReviewPrompt,
-  generateImplementationPrompt,
-  generateImplementationPlan,
-  generateFixViolationsPrompt,
-  formatPlanForAgent,
-  featureToMarkdown,
-  exportSpec,
-  exportFeature,
-  eventToMarkdown,
-  docBlockToMarkdown,
-  AGENT_SYSTEM_PROMPTS
-};