@contractspec/lib.contracts-spec 2.0.0

package/dist/node/product-intent/index.js

@@ -0,0 +1,742 @@
+import { createRequire } from "node:module";
+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 = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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/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/product-intent/contract-patch-intent.ts
+import { ZodSchemaType } from "@contractspec/lib.schema";
+import * as z from "zod";
+var PatchChangeTypeSchema = z.enum([
+  "add_field",
+  "remove_field",
+  "rename_field",
+  "add_event",
+  "update_event",
+  "add_operation",
+  "update_operation",
+  "update_form",
+  "update_policy",
+  "add_enum_value",
+  "remove_enum_value",
+  "other"
+]);
+var PatchChangeSchema = z.object({
+  type: PatchChangeTypeSchema,
+  target: z.string().min(1),
+  detail: z.string().min(1)
+});
+var PatchChangeModel = new ZodSchemaType(PatchChangeSchema, {
+  name: "PatchChange"
+});
+var ContractPatchIntentSchema = z.object({
+  featureKey: z.string().min(1),
+  changes: z.array(PatchChangeSchema),
+  acceptanceCriteria: z.array(z.string().min(1))
+});
+var ContractPatchIntentModel = new ZodSchemaType(ContractPatchIntentSchema, {
+  name: "ContractPatchIntent"
+});
+
+// src/product-intent/contract-spec-patch.ts
+import { ZodSchemaType as ZodSchemaType2 } from "@contractspec/lib.schema";
+import * as z2 from "zod";
+var ContractPatchAddSchema = z2.object({
+  path: z2.string().min(1),
+  value: z2.unknown()
+});
+var ContractPatchAddModel = new ZodSchemaType2(ContractPatchAddSchema, {
+  name: "ContractPatchAdd"
+});
+var ContractPatchUpdateSchema = z2.object({
+  path: z2.string().min(1),
+  value: z2.unknown()
+});
+var ContractPatchUpdateModel = new ZodSchemaType2(ContractPatchUpdateSchema, {
+  name: "ContractPatchUpdate"
+});
+var ContractPatchRemoveSchema = z2.object({
+  path: z2.string().min(1)
+});
+var ContractPatchRemoveModel = new ZodSchemaType2(ContractPatchRemoveSchema, {
+  name: "ContractPatchRemove"
+});
+var ContractSpecOverlaySchema = z2.object({
+  adds: z2.array(ContractPatchAddSchema).optional(),
+  updates: z2.array(ContractPatchUpdateSchema).optional(),
+  removes: z2.array(ContractPatchRemoveSchema).optional()
+});
+var ContractSpecOverlayModel = new ZodSchemaType2(ContractSpecOverlaySchema, {
+  name: "ContractSpecOverlay"
+});
+var ContractSpecPatchSchema = z2.object({
+  overlay: ContractSpecOverlaySchema
+});
+var ContractSpecPatchModel = new ZodSchemaType2(ContractSpecPatchSchema, {
+  name: "ContractSpecPatch"
+});
+
+// src/product-intent/evidence.ts
+import { ZodSchemaType as ZodSchemaType3 } from "@contractspec/lib.schema";
+import * as z3 from "zod";
+var EvidenceChunkSchema = z3.object({
+  chunkId: z3.string().min(1),
+  text: z3.string().min(1),
+  meta: z3.record(z3.string(), z3.unknown()).optional()
+});
+var EvidenceChunkModel = new ZodSchemaType3(EvidenceChunkSchema, {
+  name: "EvidenceChunk"
+});
+
+// src/product-intent/insights.ts
+import { ZodSchemaType as ZodSchemaType4 } from "@contractspec/lib.schema";
+import * as z4 from "zod";
+var CitationSchema = z4.object({
+  chunkId: z4.string().min(1),
+  quote: z4.string().min(1)
+});
+var CitationModel = new ZodSchemaType4(CitationSchema, {
+  name: "Citation"
+});
+var InsightSchema = z4.object({
+  insightId: z4.string().min(1),
+  claim: z4.string().min(1),
+  tags: z4.array(z4.string().min(1)).optional(),
+  segment: z4.string().min(1).optional(),
+  confidence: z4.number().min(0).max(1).optional(),
+  citations: z4.array(CitationSchema)
+});
+var InsightModel = new ZodSchemaType4(InsightSchema, {
+  name: "Insight"
+});
+var InsightExtractionSchema = z4.object({
+  insights: z4.array(InsightSchema)
+});
+var InsightExtractionModel = new ZodSchemaType4(InsightExtractionSchema, {
+  name: "InsightExtraction"
+});
+
+// src/product-intent/findings.ts
+import { ZodSchemaType as ZodSchemaType5 } from "@contractspec/lib.schema";
+import * as z5 from "zod";
+var EvidenceFindingSchema = z5.object({
+  findingId: z5.string().min(1),
+  summary: z5.string().min(1),
+  tags: z5.array(z5.string().min(1)).optional(),
+  citations: z5.array(CitationModel.getZod()).min(1)
+});
+var EvidenceFindingModel = new ZodSchemaType5(EvidenceFindingSchema, {
+  name: "EvidenceFinding"
+});
+var EvidenceFindingExtractionSchema = z5.object({
+  findings: z5.array(EvidenceFindingSchema)
+});
+var EvidenceFindingExtractionModel = new ZodSchemaType5(EvidenceFindingExtractionSchema, {
+  name: "EvidenceFindingExtraction"
+});
+
+// src/product-intent/impact-report.ts
+import { ZodSchemaType as ZodSchemaType6 } from "@contractspec/lib.schema";
+import * as z6 from "zod";
+var ImpactSurfacesSchema = z6.object({
+  api: z6.array(z6.string().min(1)).optional(),
+  db: z6.array(z6.string().min(1)).optional(),
+  ui: z6.array(z6.string().min(1)).optional(),
+  workflows: z6.array(z6.string().min(1)).optional(),
+  policy: z6.array(z6.string().min(1)).optional(),
+  docs: z6.array(z6.string().min(1)).optional(),
+  tests: z6.array(z6.string().min(1)).optional()
+});
+var ImpactSurfacesModel = new ZodSchemaType6(ImpactSurfacesSchema, {
+  name: "ImpactSurfaces"
+});
+var ImpactReportSchema = z6.object({
+  reportId: z6.string().min(1),
+  patchId: z6.string().min(1),
+  summary: z6.string().min(1),
+  breaks: z6.array(z6.string().min(1)).optional(),
+  mustChange: z6.array(z6.string().min(1)).optional(),
+  risky: z6.array(z6.string().min(1)).optional(),
+  surfaces: ImpactSurfacesSchema
+});
+var ImpactReportModel = new ZodSchemaType6(ImpactReportSchema, {
+  name: "ImpactReport"
+});
+
+// src/product-intent/problems.ts
+import { ZodSchemaType as ZodSchemaType7 } from "@contractspec/lib.schema";
+import * as z7 from "zod";
+var ProblemSeveritySchema = z7.enum(["low", "medium", "high"]);
+var ProblemStatementSchema = z7.object({
+  problemId: z7.string().min(1),
+  statement: z7.string().min(1),
+  evidenceIds: z7.array(z7.string().min(1)).min(1),
+  tags: z7.array(z7.string().min(1)).optional(),
+  severity: ProblemSeveritySchema.optional()
+});
+var ProblemStatementModel = new ZodSchemaType7(ProblemStatementSchema, {
+  name: "ProblemStatement"
+});
+var ProblemGroupingSchema = z7.object({
+  problems: z7.array(ProblemStatementSchema)
+});
+var ProblemGroupingModel = new ZodSchemaType7(ProblemGroupingSchema, {
+  name: "ProblemGrouping"
+});
+
+// src/product-intent/opportunity-brief.ts
+import { ZodSchemaType as ZodSchemaType8 } from "@contractspec/lib.schema";
+import * as z8 from "zod";
+var ImpactDirectionSchema = z8.enum(["up", "down"]);
+var OpportunityConfidenceSchema = z8.enum(["low", "medium", "high"]);
+var CitedTextBlockSchema = z8.object({
+  text: z8.string().min(1),
+  citations: z8.array(CitationModel.getZod())
+});
+var CitedTextBlockModel = new ZodSchemaType8(CitedTextBlockSchema, {
+  name: "CitedTextBlock"
+});
+var RiskSchema = z8.object({
+  text: z8.string().min(1),
+  citations: z8.array(CitationModel.getZod()).optional()
+});
+var RiskModel = new ZodSchemaType8(RiskSchema, {
+  name: "Risk"
+});
+var ExpectedImpactSchema = z8.object({
+  metric: z8.string().min(1),
+  direction: ImpactDirectionSchema,
+  magnitudeHint: z8.string().min(1).optional(),
+  timeframeHint: z8.string().min(1).optional()
+});
+var ExpectedImpactModel = new ZodSchemaType8(ExpectedImpactSchema, {
+  name: "ExpectedImpact"
+});
+var OpportunityBriefSchema = z8.object({
+  opportunityId: z8.string().min(1),
+  title: z8.string().min(1),
+  problem: CitedTextBlockSchema,
+  who: CitedTextBlockSchema,
+  proposedChange: CitedTextBlockSchema,
+  expectedImpact: ExpectedImpactSchema,
+  confidence: OpportunityConfidenceSchema,
+  risks: z8.array(RiskSchema).optional()
+});
+var OpportunityBriefModel = new ZodSchemaType8(OpportunityBriefSchema, {
+  name: "OpportunityBrief"
+});
+
+// src/product-intent/task-pack.ts
+import { ZodSchemaType as ZodSchemaType9 } from "@contractspec/lib.schema";
+import * as z9 from "zod";
+var TaskSurfaceSchema = z9.enum([
+  "api",
+  "db",
+  "ui",
+  "workflows",
+  "policy",
+  "docs",
+  "tests",
+  "other"
+]);
+var TaskSchema = z9.object({
+  id: z9.string().min(1),
+  title: z9.string().min(1),
+  surface: z9.array(TaskSurfaceSchema),
+  why: z9.string().min(1),
+  acceptance: z9.array(z9.string().min(1)),
+  agentPrompt: z9.string().min(1),
+  dependsOn: z9.array(z9.string().min(1)).optional()
+});
+var TaskModel = new ZodSchemaType9(TaskSchema, {
+  name: "Task"
+});
+var TaskPackSchema = z9.object({
+  packId: z9.string().min(1),
+  patchId: z9.string().min(1),
+  overview: z9.string().min(1),
+  tasks: z9.array(TaskSchema)
+});
+var TaskPackModel = new ZodSchemaType9(TaskPackSchema, {
+  name: "TaskPack"
+});
+
+// src/product-intent/tickets.ts
+import { ZodSchemaType as ZodSchemaType10 } from "@contractspec/lib.schema";
+import * as z10 from "zod";
+var TicketPrioritySchema = z10.enum(["low", "medium", "high"]);
+var TicketSchema = z10.object({
+  ticketId: z10.string().min(1),
+  title: z10.string().min(1),
+  summary: z10.string().min(1),
+  evidenceIds: z10.array(z10.string().min(1)).min(1),
+  acceptanceCriteria: z10.array(z10.string().min(1)).min(1),
+  priority: TicketPrioritySchema.optional(),
+  tags: z10.array(z10.string().min(1)).optional()
+});
+var TicketModel = new ZodSchemaType10(TicketSchema, {
+  name: "Ticket"
+});
+var TicketCollectionSchema = z10.object({
+  tickets: z10.array(TicketSchema)
+});
+var TicketCollectionModel = new ZodSchemaType10(TicketCollectionSchema, {
+  name: "TicketCollection"
+});
+
+// src/product-intent/ui-wireframe.ts
+import { ZodSchemaType as ZodSchemaType11 } from "@contractspec/lib.schema";
+import * as z11 from "zod";
+var WireframeDeviceSchema = z11.enum(["mobile", "desktop"]);
+var WireframeElementTypeSchema = z11.enum([
+  "header",
+  "text",
+  "input",
+  "button",
+  "list",
+  "card",
+  "divider",
+  "progress"
+]);
+var UiWireframeRequestSchema = z11.object({
+  screenName: z11.string().min(1),
+  device: WireframeDeviceSchema,
+  currentScreenSummary: z11.string().min(1),
+  proposedChanges: z11.array(z11.string().min(1))
+});
+var UiWireframeRequestModel = new ZodSchemaType11(UiWireframeRequestSchema, {
+  name: "UiWireframeRequest"
+});
+var UiWireframeElementSchema = z11.object({
+  type: WireframeElementTypeSchema,
+  label: z11.string().min(1),
+  notes: z11.string().min(1).optional()
+});
+var UiWireframeElementModel = new ZodSchemaType11(UiWireframeElementSchema, {
+  name: "UiWireframeElement"
+});
+var UiWireframeLayoutSchema = z11.object({
+  layout: z11.array(UiWireframeElementSchema)
+});
+var UiWireframeLayoutModel = new ZodSchemaType11(UiWireframeLayoutSchema, {
+  name: "UiWireframeLayout"
+});
+// src/product-intent/spec.ts
+import { ZodSchemaType as ZodSchemaType12 } from "@contractspec/lib.schema";
+import * as z12 from "zod";
+var ProductIntentMetaSchema = z12.object({
+  key: z12.string().min(1),
+  version: z12.string().min(1),
+  description: z12.string().min(1),
+  stability: z12.nativeEnum(StabilityEnum),
+  owners: z12.array(z12.string().min(1)),
+  tags: z12.array(z12.string().min(1)),
+  title: z12.string().min(1).optional(),
+  domain: z12.string().min(1).optional(),
+  docId: z12.array(z12.string().min(1)).optional(),
+  goal: z12.string().min(1).optional(),
+  context: z12.string().min(1).optional()
+});
+var ProductIntentSpecSchema = z12.object({
+  id: z12.string().min(1),
+  meta: ProductIntentMetaSchema,
+  question: z12.string().min(1),
+  runtimeContext: z12.unknown().optional(),
+  findings: EvidenceFindingExtractionModel.getZod().optional(),
+  insights: InsightExtractionModel.getZod().optional(),
+  problems: ProblemGroupingModel.getZod().optional(),
+  brief: OpportunityBriefModel.getZod().optional(),
+  tickets: TicketCollectionModel.getZod().optional(),
+  patchIntent: ContractPatchIntentModel.getZod().optional(),
+  patch: ContractSpecPatchModel.getZod().optional(),
+  impact: ImpactReportModel.getZod().optional(),
+  tasks: TaskPackModel.getZod().optional()
+});
+var ProductIntentSpecModel = new ZodSchemaType12(ProductIntentSpecSchema, {
+  name: "ProductIntentSpec"
+});
+function defineProductIntentSpec(spec) {
+  return spec;
+}
+
+// src/product-intent/registry.ts
+class ProductIntentRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("product-intent", items);
+  }
+  set(spec) {
+    const key = keyOfSpecContract(spec);
+    this.items.set(key, spec);
+    return this;
+  }
+  getById(id) {
+    return this.list().find((spec) => spec.id === id);
+  }
+  delete(id) {
+    const target = this.list().find((spec) => spec.id === id);
+    if (!target)
+      return false;
+    const key = keyOfSpecContract(target);
+    return this.items.delete(key);
+  }
+  deleteByKey(key, version) {
+    return this.items.delete(`${key}.v${version}`);
+  }
+  clear() {
+    this.items.clear();
+  }
+}
+
+// src/product-intent/runtime.ts
+class ProductIntentRuntime {
+  registry;
+  opts;
+  constructor(opts, registry) {
+    this.opts = opts;
+    this.registry = registry ?? new ProductIntentRegistry;
+  }
+  registerIntent(spec) {
+    this.registry.register(spec);
+  }
+  async runDiscovery(params) {
+    const { id, meta, question, context } = params;
+    const maxEvidenceChunks = params.maxEvidenceChunks ?? this.opts.maxEvidenceChunks ?? 20;
+    const spec = {
+      id,
+      meta,
+      question,
+      runtimeContext: context
+    };
+    const evidence2 = await this.opts.fetchEvidence({
+      query: question,
+      maxChunks: maxEvidenceChunks,
+      context
+    });
+    const insights2 = await this.extractInsights(question, evidence2, context);
+    spec.insights = insights2;
+    if (this.opts.onInsightsGenerated) {
+      await this.opts.onInsightsGenerated(insights2, context);
+    }
+    const brief = await this.synthesiseBrief(question, insights2, context);
+    spec.brief = brief;
+    if (this.opts.onBriefSynthesised) {
+      await this.opts.onBriefSynthesised(brief, context);
+    }
+    const intent = await this.generatePatchIntent(brief, context);
+    spec.patchIntent = intent;
+    if (this.opts.onPatchIntentGenerated) {
+      await this.opts.onPatchIntentGenerated(intent, context);
+    }
+    const patch = await this.generatePatch(intent, context);
+    spec.patch = patch;
+    if (this.opts.onPatchGenerated) {
+      await this.opts.onPatchGenerated(patch, context);
+    }
+    const impact = await this.generateImpactReport(intent, patch, context);
+    spec.impact = impact;
+    if (this.opts.onImpactGenerated) {
+      await this.opts.onImpactGenerated(impact, context);
+    }
+    const tasks = await this.generateTasks(brief, intent, impact, context);
+    spec.tasks = tasks;
+    if (this.opts.onTasksGenerated) {
+      await this.opts.onTasksGenerated(tasks, context);
+    }
+    this.registry.set(spec);
+    return spec;
+  }
+  async extractInsights(_question, _evidence, _context) {
+    throw new Error("extractInsights() not implemented. Provide an implementation in a subclass.");
+  }
+  async synthesiseBrief(_question, _insights, _context) {
+    throw new Error("synthesiseBrief() not implemented. Provide an implementation in a subclass.");
+  }
+  async generatePatchIntent(_brief, _context) {
+    throw new Error("generatePatchIntent() not implemented. Provide an implementation in a subclass.");
+  }
+  async generatePatch(_intent, _context) {
+    throw new Error("generatePatch() not implemented. Provide an implementation in a subclass.");
+  }
+  async generateImpactReport(_intent, _patch, _context) {
+    throw new Error("generateImpactReport() not implemented. Provide an implementation in a subclass.");
+  }
+  async generateTasks(_brief, _intent, _impact, _context) {
+    throw new Error("generateTasks() not implemented. Provide an implementation in a subclass.");
+  }
+}
+export {
+  defineProductIntentSpec,
+  UiWireframeRequestModel,
+  UiWireframeLayoutModel,
+  UiWireframeElementModel,
+  TicketModel,
+  TicketCollectionModel,
+  TaskPackModel,
+  TaskModel,
+  RiskModel,
+  ProductIntentSpecModel,
+  ProductIntentRuntime,
+  ProductIntentRegistry,
+  ProblemStatementModel,
+  ProblemGroupingModel,
+  PatchChangeModel,
+  OpportunityBriefModel,
+  InsightModel,
+  InsightExtractionModel,
+  ImpactSurfacesModel,
+  ImpactReportModel,
+  ExpectedImpactModel,
+  EvidenceFindingModel,
+  EvidenceFindingExtractionModel,
+  EvidenceChunkModel,
+  ContractSpecPatchModel,
+  ContractSpecOverlayModel,
+  ContractPatchUpdateModel,
+  ContractPatchRemoveModel,
+  ContractPatchIntentModel,
+  ContractPatchAddModel,
+  CitedTextBlockModel,
+  CitationModel
+};