@contractspec/lib.contracts 1.56.1 → 1.58.0

package/dist/llm/prompts.js

@@ -1,11 +1,1257 @@
-import { operationSpecToAgentPrompt, operationSpecToFullMarkdown } from "./exporters.js";
+// @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: []
+  }
+});
 
-//#region src/llm/prompts.ts
-/**
-* System prompts for different agent types.
-*/
-const AGENT_SYSTEM_PROMPTS = {
-	"claude-code": `You are an expert TypeScript developer working with ContractSpec, a spec-first development framework.
+// 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\`)
@@ -22,7 +1268,7 @@ When implementing specs:
 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.
+  "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
@@ -38,7 +1284,7 @@ When working with specs:
 - Respect policy constraints
 
 Use the project's existing patterns and conventions.`,
-	"generic-mcp": `You are a code generation assistant working with ContractSpec specifications.
+  "generic-mcp": `You are a code generation assistant working with ContractSpec specifications.
 
 ContractSpec specs define:
 - meta: name, version, kind (command/query), description, goal, context
@@ -50,21 +1296,24 @@ ContractSpec specs define:
 Your task is to generate or modify code that complies with the given specification.
 Follow the spec exactly and handle all defined cases.`
 };
-/**
-* Generate an implementation prompt for a specific agent type.
-*/
 function generateImplementationPrompt(spec, agent, options) {
-	const systemPrompt = AGENT_SYSTEM_PROMPTS[agent];
-	const specMarkdown = operationSpecToFullMarkdown(spec);
-	let taskPrompt;
-	if (agent === "claude-code") taskPrompt = `## Implementation Task
+  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}\`\n` : ""}
-${options?.existingCode ? `**Existing code to modify:**\n\`\`\`typescript\n${options.existingCode}\n\`\`\`\n` : ""}
+${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
@@ -74,39 +1323,45 @@ Generate a complete, production-ready TypeScript implementation that:
 5. Includes JSDoc documentation
 
 Provide ONLY the TypeScript code.`;
-	else if (agent === "cursor-cli") taskPrompt = `Implement this ContractSpec operation.
+  } else if (agent === "cursor-cli") {
+    taskPrompt = `Implement this ContractSpec operation.
 
 ${specMarkdown}
 
-${options?.targetPath ? `Target: ${options.targetPath}\n` : ""}
+${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
-	};
-}
-/**
-* Generate a test generation prompt.
-*/
+  } else {
+    taskPrompt = operationSpecToAgentPrompt(spec, {
+      taskType: "implement",
+      existingCode: options?.existingCode
+    });
+  }
+  return {
+    agent,
+    systemPrompt,
+    taskPrompt
+  };
+}
 function generateTestPrompt(spec, agent, options) {
-	const framework = options?.testFramework ?? "vitest";
-	const taskPrompt = `## Test Generation Task
+  const framework = options?.testFramework ?? "vitest";
+  const specMarkdown = operationSpecToFullMarkdown(spec);
+  const taskPrompt = `## Test Generation Task
 
 Generate comprehensive tests for this specification:
 
-${operationSpecToFullMarkdown(spec)}
+${specMarkdown}
 
-${options?.implementationCode ? `**Implementation:**\n\`\`\`typescript\n${options.implementationCode}\n\`\`\`\n` : ""}
+${options?.implementationCode ? `**Implementation:**
+\`\`\`typescript
+${options.implementationCode}
+\`\`\`
+` : ""}
 
 **Test Framework:** ${framework}
 
@@ -120,22 +1375,20 @@ Generate tests that:
 Use descriptive test names: "should [behavior] when [condition]"
 
 Provide a complete test file.`;
-	return {
-		agent,
-		systemPrompt: AGENT_SYSTEM_PROMPTS[agent],
-		taskPrompt
-	};
-}
-/**
-* Generate a code review prompt.
-*/
+  return {
+    agent,
+    systemPrompt: AGENT_SYSTEM_PROMPTS[agent],
+    taskPrompt
+  };
+}
 function generateReviewPrompt(spec, agent, implementationCode) {
-	const taskPrompt = `## Code Review Task
+  const specMarkdown = operationSpecToFullMarkdown(spec);
+  const taskPrompt = `## Code Review Task
 
 Review this implementation against its specification:
 
 **Specification:**
-${operationSpecToFullMarkdown(spec)}
+${specMarkdown}
 
 **Implementation:**
 \`\`\`typescript
@@ -158,24 +1411,20 @@ List any issues with severity (error/warning/info)
 List improvements and recommendations
 
 Be thorough and precise. Focus on spec compliance first, then code quality.`;
-	return {
-		agent,
-		systemPrompt: AGENT_SYSTEM_PROMPTS[agent],
-		taskPrompt
-	};
-}
-/**
-* Generate a verification prompt for AI-powered semantic review.
-*/
+  return {
+    agent,
+    systemPrompt: AGENT_SYSTEM_PROMPTS[agent],
+    taskPrompt
+  };
+}
 function generateVerificationPrompt(spec, implementationCode) {
-	return {
-		agent: "generic-mcp",
-		taskPrompt: `## Semantic Verification Task
+  const specMarkdown = operationSpecToFullMarkdown(spec);
+  const taskPrompt = `## Semantic Verification Task
 
 Verify that this implementation fulfills the specification's intent.
 
 **Specification:**
-${operationSpecToFullMarkdown(spec)}
+${specMarkdown}
 
 **Implementation:**
 \`\`\`typescript
@@ -203,129 +1452,148 @@ Analyze and respond with JSON:
   ],
   "summary": "Brief summary of verification results"
 }
-\`\`\``
-	};
+\`\`\``;
+  return {
+    agent: "generic-mcp",
+    taskPrompt
+  };
 }
-/**
-* Generate a feature implementation plan.
-*/
 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 !== void 0) 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;
-	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: [
-			"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"
-		]
-	};
-}
-/**
-* Format an implementation plan for a specific agent.
-*/
+  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}
+  let taskPrompt;
+  if (agent === "claude-code") {
+    taskPrompt = `## Implementation Plan: ${plan.target.key}.v${plan.target.version}
 
 ### Context
 **Goal:** ${plan.context.goal}
@@ -336,7 +1604,8 @@ function formatPlanForAgent(plan, agent) {
 ${plan.specMarkdown}
 
 ### File Structure
-${plan.fileStructure.map((f) => `- \`${f.path}\` (${f.type}): ${f.purpose}`).join("\n")}
+${plan.fileStructure.map((f) => `- \`${f.path}\` (${f.type}): ${f.purpose}`).join(`
+`)}
 
 ### Implementation Steps
 ${plan.steps.map((s) => `
@@ -344,19 +1613,32 @@ ${plan.steps.map((s) => `
 ${s.description}
 
 **Acceptance Criteria:**
-${s.acceptanceCriteria.map((c) => `- [ ] ${c}`).join("\n")}
-`).join("\n")}
+${s.acceptanceCriteria.map((c) => `- [ ] ${c}`).join(`
+`)}
+`).join(`
+`)}
 
 ### Constraints
-${plan.constraints.policy.length ? `**Policy:**\n${plan.constraints.policy.map((p) => `- ${p}`).join("\n")}\n` : ""}
-${plan.constraints.security.length ? `**Security:**\n${plan.constraints.security.map((s) => `- ${s}`).join("\n")}\n` : ""}
-${plan.constraints.pii.length ? `**PII Handling:**\n${plan.constraints.pii.map((p) => `- ${p}`).join("\n")}\n` : ""}
+${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("\n")}
+${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}
+  } else if (agent === "cursor-cli") {
+    taskPrompt = `# ${plan.target.key}.v${plan.target.version}
 
 ${plan.context.goal}
 
@@ -364,34 +1646,38 @@ ${plan.context.goal}
 ${plan.specMarkdown}
 
 ## Files to create
-${plan.fileStructure.map((f) => `${f.type}: ${f.path}`).join("\n")}
+${plan.fileStructure.map((f) => `${f.type}: ${f.path}`).join(`
+`)}
 
 ## Steps
-${plan.steps.map((s) => `${s.order}. ${s.title}`).join("\n")}`;
-	else taskPrompt = `Implementation plan for ${plan.target.key}.v${plan.target.version}
+${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("\n")}`;
-	return {
-		agent,
-		systemPrompt: AGENT_SYSTEM_PROMPTS[agent],
-		taskPrompt
-	};
-}
-/**
-* Generate a fix violations prompt after verification.
-*/
+${plan.steps.map((s) => `${s.order}. ${s.title}: ${s.description}`).join(`
+`)}`;
+  }
+  return {
+    agent,
+    systemPrompt: AGENT_SYSTEM_PROMPTS[agent],
+    taskPrompt
+  };
+}
 function generateFixViolationsPrompt(spec, implementationCode, violations) {
-	return {
-		agent: "generic-mcp",
-		taskPrompt: `## Fix Specification 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:**
-${operationSpecToFullMarkdown(spec)}
+${specMarkdown}
 
 **Current Implementation:**
 \`\`\`typescript
@@ -399,12 +1685,22 @@ ${implementationCode}
 \`\`\`
 
 **Violations Found:**
-${violations.map((v, i) => `${i + 1}. ${v.message}${v.suggestion ? `\n   Suggestion: ${v.suggestion}` : ""}`).join("\n")}
+${violationsList}
 
 Fix ALL violations while maintaining existing functionality.
-Provide the corrected implementation.`
-	};
+Provide the corrected implementation.`;
+  return {
+    agent: "generic-mcp",
+    taskPrompt
+  };
 }
-
-//#endregion
-export { AGENT_SYSTEM_PROMPTS, formatPlanForAgent, generateFixViolationsPrompt, generateImplementationPlan, generateImplementationPrompt, generateReviewPrompt, generateTestPrompt, generateVerificationPrompt };
+export {
+  generateVerificationPrompt,
+  generateTestPrompt,
+  generateReviewPrompt,
+  generateImplementationPrompt,
+  generateImplementationPlan,
+  generateFixViolationsPrompt,
+  formatPlanForAgent,
+  AGENT_SYSTEM_PROMPTS
+};