@contractspec/lib.product-intent-utils 1.57.0 → 1.59.0

package/dist/browser/index.js

@@ -0,0 +1,1592 @@
+// src/prompts.ts
+function formatEvidenceForModel(chunks, maxChars = 900) {
+  const safe = chunks.map((chunk) => ({
+    chunkId: chunk.chunkId,
+    text: chunk.text.length > maxChars ? `${chunk.text.slice(0, maxChars)}...` : chunk.text,
+    meta: chunk.meta ?? {}
+  }));
+  return JSON.stringify({ evidenceChunks: safe }, null, 2);
+}
+var JSON_ONLY_RULES = `
+You MUST output valid JSON ONLY.
+- Do not wrap in markdown fences.
+- Do not include any commentary.
+- Do not include trailing commas.
+- Use double quotes for all keys and string values.
+`;
+var CITATION_RULES = `
+CITATION RULES (strict):
+- You may ONLY cite from the provided evidenceChunks.
+- Each citation must include:
+  - "chunkId": exactly one of the provided chunkId values
+  - "quote": an exact substring copied from that chunk's text
+- Do NOT invent quotes.
+- Keep quotes short (<= 240 chars).
+- If you cannot support a claim with evidence, do not make the claim.
+`;
+function promptExtractInsights(params) {
+  return `
+You are extracting ATOMIC, EVIDENCE-GROUNDED insights to answer a product discovery question.
+
+Question:
+${params.question}
+
+Evidence:
+${params.evidenceJSON}
+
+Task:
+Return JSON with:
+{
+  "insights": [
+    {
+      "insightId": "ins_001",
+      "claim": "...",
+      "tags": ["..."],
+      "segment": "...",
+      "confidence": 0.0,
+      "citations": [{ "chunkId": "...", "quote": "..." }]
+    }
+  ]
+}
+
+Guidelines:
+- Produce 8 to 16 insights.
+- Each insight must be supported by 1 to 3 citations.
+- Prefer user pain, blockers, confusions, workarounds, requests, and measurable outcomes.
+- If evidence conflicts, include both sides as separate insights.
+${CITATION_RULES}
+${JSON_ONLY_RULES}
+`.trim();
+}
+function promptSynthesizeBrief(params) {
+  const allowed = JSON.stringify({ allowedChunkIds: params.allowedChunkIds }, null, 2);
+  return `
+You are synthesizing a product opportunity brief that is STRICTLY grounded in evidence.
+
+Question:
+${params.question}
+
+Extracted insights (already grounded):
+${params.insightsJSON}
+
+Allowed citations:
+${allowed}
+
+Return JSON with exactly this shape:
+{
+  "opportunityId": "opp_001",
+  "title": "short title",
+  "problem": { "text": "...", "citations": [ { "chunkId": "...", "quote": "..." } ] },
+  "who": { "text": "...", "citations": [ ... ] },
+  "proposedChange": { "text": "...", "citations": [ ... ] },
+  "expectedImpact": { "metric": "activation_rate", "direction": "up", "magnitudeHint": "...", "timeframeHint": "..." },
+  "confidence": "low|medium|high",
+  "risks": [ { "text": "...", "citations": [ ... ] } ]
+}
+
+Rules:
+- The fields problem/who/proposedChange MUST each have >=1 citation.
+- All citations must use allowedChunkIds and include exact quotes.
+- Keep the brief concise and specific.
+${CITATION_RULES}
+${JSON_ONLY_RULES}
+`.trim();
+}
+function promptSkepticCheck(params) {
+  return `
+You are auditing a brief for unsupported claims and citation misuse.
+
+Brief:
+${params.briefJSON}
+
+Evidence:
+${params.evidenceJSON}
+
+Return JSON:
+{
+  "issues": [
+    {
+      "path": "problem|who|proposedChange|risks[i]|...",
+      "reason": "unsupported|quote_not_exact|wrong_chunk|too_vague|overreach",
+      "fix": "what to change"
+    }
+  ]
+}
+
+Rules:
+- If everything is supported, return {"issues": []}.
+- Be strict. If a statement is not clearly supported by citations, flag it.
+${JSON_ONLY_RULES}
+`.trim();
+}
+function promptGeneratePatchIntent(params) {
+  return `
+You are generating a ContractPatchIntent from an OpportunityBrief.
+
+OpportunityBrief:
+${params.briefJSON}
+
+Return JSON:
+{
+  "featureKey": "activation_onboarding",
+  "changes": [
+    { "type": "add_event|update_form|update_operation|add_field|...", "target": "string", "detail": "string" }
+  ],
+  "acceptanceCriteria": ["..."]
+}
+
+Rules:
+- Keep changes <= 12.
+- Detail should be minimal and explicit.
+- Acceptance criteria must be testable and verifiable.
+${JSON_ONLY_RULES}
+`.trim();
+}
+function promptGenerateGenericSpecOverlay(params) {
+  return `
+You are generating a GENERIC spec overlay patch based on PatchIntent.
+You must respect the base spec snippet.
+
+Base spec snippet (context):
+${params.baseSpecSnippet}
+
+PatchIntent:
+${params.patchIntentJSON}
+
+Return JSON:
+{
+  "overlay": {
+    "adds": [ { "path": "dot.path", "value": {} } ],
+    "updates": [ { "path": "dot.path", "value": {} } ],
+    "removes": [ { "path": "dot.path" } ]
+  }
+}
+
+Rules:
+- Only reference paths that plausibly exist in the base spec snippet or add new ones under reasonable roots.
+- Keep values small. Avoid massive blobs.
+${JSON_ONLY_RULES}
+`.trim();
+}
+function promptGenerateImpactReport(params) {
+  return `
+You are generating an Impact Report for a spec patch.
+
+PatchIntent:
+${params.patchIntentJSON}
+
+Overlay:
+${params.overlayJSON}
+
+Compiler output (if present):
+${params.compilerOutputText ?? "(none)"}
+
+Return JSON:
+{
+  "reportId": "impact_001",
+  "patchId": "patch_001",
+  "summary": "...",
+  "breaks": ["..."],
+  "mustChange": ["..."],
+  "risky": ["..."],
+  "surfaces": {
+    "api": ["..."],
+    "db": ["..."],
+    "ui": ["..."],
+    "workflows": ["..."],
+    "policy": ["..."],
+    "docs": ["..."],
+    "tests": ["..."]
+  }
+}
+
+Rules:
+- Be concrete: name what changes and why.
+- If unsure, put it under "risky" not "breaks".
+- Keep each item short.
+${JSON_ONLY_RULES}
+`.trim();
+}
+function promptGenerateTaskPack(params) {
+  return `
+You are generating an agent-ready Task Pack to implement a product change safely.
+
+Repo context:
+${params.repoContext ?? "(none)"}
+
+OpportunityBrief:
+${params.briefJSON}
+
+PatchIntent:
+${params.patchIntentJSON}
+
+Impact report:
+${params.impactJSON}
+
+Return JSON:
+{
+  "packId": "tasks_001",
+  "patchId": "patch_001",
+  "overview": "...",
+  "tasks": [
+    {
+      "id": "t1",
+      "title": "...",
+      "surface": ["api", "db", "ui", "tests"],
+      "why": "...",
+      "acceptance": ["..."],
+      "agentPrompt": "...",
+      "dependsOn": []
+    }
+  ]
+}
+
+Rules:
+- 6 to 12 tasks.
+- Each task must have testable acceptance criteria.
+- Agent prompts must be copy-paste friendly and mention expected files/surfaces.
+- Include at least one tests task.
+${JSON_ONLY_RULES}
+`.trim();
+}
+function promptWireframeImage(params) {
+  return `
+Create a minimal grayscale wireframe (${params.device}) for screen: "${params.screenName}".
+
+Style rules:
+- Wireframe only, grayscale, no brand colors, no gradients
+- Simple boxes, labels, and spacing
+- High readability, minimal detail, like a product spec wireframe
+- No decorative illustrations
+
+Current screen summary:
+${params.currentScreenSummary}
+
+Proposed changes (must be reflected in the wireframe):
+- ${params.proposedChanges.join(`
+- `)}
+
+Output: a single wireframe image that clearly shows the updated layout.
+`.trim();
+}
+function promptWireframeLayoutJSON(params) {
+  return `
+You are generating a simple UI wireframe layout JSON (NOT an image).
+Screen: "${params.screenName}" (${params.device})
+
+Proposed changes:
+- ${params.proposedChanges.join(`
+- `)}
+
+Return JSON:
+{
+  "layout": [
+    { "type": "header", "label": "..." },
+    { "type": "text", "label": "..." },
+    { "type": "input", "label": "..." },
+    { "type": "button", "label": "..." }
+  ]
+}
+
+Rules:
+- 8 to 18 elements.
+- Must reflect proposed changes.
+- Labels should be clear and specific.
+${JSON_ONLY_RULES}
+`.trim();
+}
+function promptGenerateSyntheticInterviews(params) {
+  return `
+Generate ${params.count} synthetic customer interview transcripts for this product context:
+${params.productContext}
+
+Personas to cover:
+- ${params.personas.join(`
+- `)}
+
+Requirements:
+- Each transcript 400-900 words
+- Include realistic friction, objections, and competing priorities
+- Include at least 6 quotable lines per transcript (short, direct)
+- Include at least one conflicting opinion across the set
+- Format as plain text with speaker labels (INTERVIEWER:, CUSTOMER:)
+
+Return JSON:
+{
+  "items": [
+    { "title": "...", "persona": "...", "segment": "...", "transcript": "..." }
+  ]
+}
+
+${JSON_ONLY_RULES}
+`.trim();
+}
+// src/ticket-prompts.ts
+function promptExtractEvidenceFindings(params) {
+  return `
+You are extracting evidence findings grounded in transcript excerpts.
+
+Question:
+${params.question}
+
+Evidence:
+${params.evidenceJSON}
+
+Return JSON:
+{
+  "findings": [
+    {
+      "findingId": "find_001",
+      "summary": "...",
+      "tags": ["..."],
+      "citations": [{ "chunkId": "...", "quote": "..." }]
+    }
+  ]
+}
+
+Rules:
+- Produce 8 to 18 findings.
+- Each finding must include at least 1 citation.
+- Summaries must be specific and short.
+- Quotes must be copied character-for-character from the chunk text (no paraphrasing, no ellipses).
+- Preserve punctuation, smart quotes, and special hyphens exactly as shown in the chunk text.
+${CITATION_RULES}
+${JSON_ONLY_RULES}
+  `.trim();
+}
+function promptGroupProblems(params) {
+  const allowed = JSON.stringify({ findingIds: params.findingIds }, null, 2);
+  return `
+You are grouping evidence findings into problem statements.
+
+Question:
+${params.question}
+
+Findings:
+${params.findingsJSON}
+
+Allowed finding IDs:
+${allowed}
+
+Return JSON:
+{
+  "problems": [
+    {
+      "problemId": "prob_001",
+      "statement": "...",
+      "evidenceIds": ["find_001"],
+      "tags": ["..."],
+      "severity": "low|medium|high"
+    }
+  ]
+}
+
+Rules:
+- Each problem must reference 1 to 6 evidenceIds.
+- evidenceIds must be drawn from the allowed finding IDs.
+- Keep statements short and actionable.
+${JSON_ONLY_RULES}
+  `.trim();
+}
+function promptGenerateTickets(params) {
+  return `
+You are generating implementation tickets grounded in evidence.
+
+Question:
+${params.question}
+
+Problems:
+${params.problemsJSON}
+
+Evidence findings:
+${params.findingsJSON}
+
+Return JSON:
+{
+  "tickets": [
+    {
+      "ticketId": "t_001",
+      "title": "...",
+      "summary": "...",
+      "evidenceIds": ["find_001"],
+      "acceptanceCriteria": ["..."]
+    }
+  ]
+}
+
+Rules:
+- 1 to 2 tickets per problem.
+- Every ticket must include evidenceIds and acceptanceCriteria.
+- Acceptance criteria must be testable.
+- Each acceptanceCriteria item must be <= 160 characters.
+${JSON_ONLY_RULES}
+  `.trim();
+}
+function promptSuggestPatchIntent(params) {
+  return `
+You are generating a ContractPatchIntent from an evidence-backed ticket.
+
+Ticket:
+${params.ticketJSON}
+
+Return JSON:
+{
+  "featureKey": "feature_slug",
+  "changes": [
+    { "type": "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", "target": "string", "detail": "string" }
+  ],
+  "acceptanceCriteria": ["..."]
+}
+
+Rules:
+- Keep changes <= 8.
+- Each change must be concrete and scoped.
+- Acceptance criteria must be testable and derived from the ticket.
+- Each acceptanceCriteria item must be <= 140 characters.
+${JSON_ONLY_RULES}
+  `.trim();
+}
+// src/validators.ts
+import {
+  CitationModel,
+  ContractPatchIntentModel,
+  ImpactReportModel,
+  InsightExtractionModel,
+  OpportunityBriefModel,
+  TaskPackModel
+} from "@contractspec/lib.contracts/product-intent/types";
+function assertStringLength(value, path, bounds) {
+  if (bounds.min !== undefined && value.length < bounds.min) {
+    throw new Error(`Expected ${path} to be at least ${bounds.min} characters, got ${value.length}`);
+  }
+  if (bounds.max !== undefined && value.length > bounds.max) {
+    throw new Error(`Expected ${path} to be at most ${bounds.max} characters, got ${value.length}`);
+  }
+}
+function assertArrayLength(value, path, bounds) {
+  if (bounds.min !== undefined && value.length < bounds.min) {
+    throw new Error(`Expected ${path} to have at least ${bounds.min} items, got ${value.length}`);
+  }
+  if (bounds.max !== undefined && value.length > bounds.max) {
+    throw new Error(`Expected ${path} to have at most ${bounds.max} items, got ${value.length}`);
+  }
+}
+function assertNumberRange(value, path, bounds) {
+  if (bounds.min !== undefined && value < bounds.min) {
+    throw new Error(`Expected ${path} to be >= ${bounds.min}, got ${value}`);
+  }
+  if (bounds.max !== undefined && value > bounds.max) {
+    throw new Error(`Expected ${path} to be <= ${bounds.max}, got ${value}`);
+  }
+}
+function parseStrictJSON(schema, raw) {
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    throw new Error("Model did not return JSON (missing leading { or [)");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON: ${message}`);
+  }
+  return schema.getZod().parse(parsed);
+}
+function buildChunkIndex(chunks) {
+  const map = new Map;
+  for (const chunk of chunks) {
+    map.set(chunk.chunkId, chunk);
+  }
+  return map;
+}
+function validateCitation(citation, chunkIndex, opts) {
+  const maxQuoteLen = opts?.maxQuoteLen ?? 240;
+  const requireExactSubstring = opts?.requireExactSubstring ?? true;
+  const parsed = CitationModel.getZod().parse(citation);
+  assertStringLength(parsed.quote, "citation.quote", {
+    min: 1,
+    max: maxQuoteLen
+  });
+  const chunk = chunkIndex.get(parsed.chunkId);
+  if (!chunk) {
+    throw new Error(`Citation references unknown chunkId: ${parsed.chunkId}`);
+  }
+  if (requireExactSubstring && !chunk.text.includes(parsed.quote)) {
+    throw new Error(`Citation quote is not an exact substring of chunk ${parsed.chunkId}`);
+  }
+  return parsed;
+}
+function validateCitationsInTextBlock(block, chunkIndex) {
+  assertStringLength(block.text, "textBlock.text", { min: 1 });
+  if (!block.citations?.length) {
+    throw new Error("Missing required citations");
+  }
+  const citations = block.citations.map((c) => validateCitation(c, chunkIndex));
+  return { text: block.text, citations };
+}
+function validateOpportunityBrief(raw, chunks) {
+  const chunkIndex = buildChunkIndex(chunks);
+  const brief = parseStrictJSON(OpportunityBriefModel, raw);
+  assertStringLength(brief.opportunityId, "opportunityId", { min: 1 });
+  assertStringLength(brief.title, "title", { min: 1, max: 120 });
+  validateCitationsInTextBlock(brief.problem, chunkIndex);
+  validateCitationsInTextBlock(brief.who, chunkIndex);
+  validateCitationsInTextBlock(brief.proposedChange, chunkIndex);
+  assertStringLength(brief.expectedImpact.metric, "expectedImpact.metric", {
+    min: 1,
+    max: 64
+  });
+  if (brief.expectedImpact.magnitudeHint) {
+    assertStringLength(brief.expectedImpact.magnitudeHint, "expectedImpact.magnitudeHint", { max: 64 });
+  }
+  if (brief.expectedImpact.timeframeHint) {
+    assertStringLength(brief.expectedImpact.timeframeHint, "expectedImpact.timeframeHint", { max: 64 });
+  }
+  if (brief.risks) {
+    for (const risk of brief.risks) {
+      assertStringLength(risk.text, "risks[].text", { min: 1, max: 240 });
+      if (risk.citations) {
+        for (const c of risk.citations) {
+          validateCitation(c, chunkIndex);
+        }
+      }
+    }
+  }
+  return brief;
+}
+function validateInsightExtraction(raw, chunks) {
+  const chunkIndex = buildChunkIndex(chunks);
+  const data = parseStrictJSON(InsightExtractionModel, raw);
+  assertArrayLength(data.insights, "insights", { min: 1, max: 30 });
+  for (const insight of data.insights) {
+    assertStringLength(insight.insightId, "insights[].insightId", { min: 1 });
+    assertStringLength(insight.claim, "insights[].claim", {
+      min: 1,
+      max: 320
+    });
+    if (insight.tags) {
+      for (const tag of insight.tags) {
+        assertStringLength(tag, "insights[].tags[]", { min: 1 });
+      }
+    }
+    if (insight.confidence !== undefined) {
+      assertNumberRange(insight.confidence, "insights[].confidence", {
+        min: 0,
+        max: 1
+      });
+    }
+    assertArrayLength(insight.citations, "insights[].citations", { min: 1 });
+    for (const c of insight.citations) {
+      validateCitation(c, chunkIndex);
+    }
+  }
+  return data;
+}
+function validatePatchIntent(raw) {
+  const data = parseStrictJSON(ContractPatchIntentModel, raw);
+  assertStringLength(data.featureKey, "featureKey", { min: 1, max: 80 });
+  assertArrayLength(data.changes, "changes", { min: 1, max: 25 });
+  for (const change of data.changes) {
+    assertStringLength(change.target, "changes[].target", { min: 1 });
+    assertStringLength(change.detail, "changes[].detail", { min: 1 });
+  }
+  assertArrayLength(data.acceptanceCriteria, "acceptanceCriteria", {
+    min: 1,
+    max: 12
+  });
+  for (const item of data.acceptanceCriteria) {
+    assertStringLength(item, "acceptanceCriteria[]", { min: 1, max: 140 });
+  }
+  return data;
+}
+function validateImpactReport(raw) {
+  const data = parseStrictJSON(ImpactReportModel, raw);
+  assertStringLength(data.reportId, "reportId", { min: 1 });
+  assertStringLength(data.patchId, "patchId", { min: 1 });
+  assertStringLength(data.summary, "summary", { min: 1, max: 200 });
+  if (data.breaks) {
+    for (const item of data.breaks) {
+      assertStringLength(item, "breaks[]", { min: 1, max: 160 });
+    }
+  }
+  if (data.mustChange) {
+    for (const item of data.mustChange) {
+      assertStringLength(item, "mustChange[]", { min: 1, max: 160 });
+    }
+  }
+  if (data.risky) {
+    for (const item of data.risky) {
+      assertStringLength(item, "risky[]", { min: 1, max: 160 });
+    }
+  }
+  const surfaces = data.surfaces;
+  if (surfaces.api) {
+    for (const item of surfaces.api) {
+      assertStringLength(item, "surfaces.api[]", { min: 1, max: 140 });
+    }
+  }
+  if (surfaces.db) {
+    for (const item of surfaces.db) {
+      assertStringLength(item, "surfaces.db[]", { min: 1, max: 140 });
+    }
+  }
+  if (surfaces.ui) {
+    for (const item of surfaces.ui) {
+      assertStringLength(item, "surfaces.ui[]", { min: 1, max: 140 });
+    }
+  }
+  if (surfaces.workflows) {
+    for (const item of surfaces.workflows) {
+      assertStringLength(item, "surfaces.workflows[]", { min: 1, max: 140 });
+    }
+  }
+  if (surfaces.policy) {
+    for (const item of surfaces.policy) {
+      assertStringLength(item, "surfaces.policy[]", { min: 1, max: 140 });
+    }
+  }
+  if (surfaces.docs) {
+    for (const item of surfaces.docs) {
+      assertStringLength(item, "surfaces.docs[]", { min: 1, max: 140 });
+    }
+  }
+  if (surfaces.tests) {
+    for (const item of surfaces.tests) {
+      assertStringLength(item, "surfaces.tests[]", { min: 1, max: 140 });
+    }
+  }
+  return data;
+}
+function validateTaskPack(raw) {
+  const data = parseStrictJSON(TaskPackModel, raw);
+  assertStringLength(data.packId, "packId", { min: 1 });
+  assertStringLength(data.patchId, "patchId", { min: 1 });
+  assertStringLength(data.overview, "overview", { min: 1, max: 240 });
+  assertArrayLength(data.tasks, "tasks", { min: 3, max: 14 });
+  for (const task of data.tasks) {
+    assertStringLength(task.id, "tasks[].id", { min: 1 });
+    assertStringLength(task.title, "tasks[].title", { min: 1, max: 120 });
+    assertArrayLength(task.surface, "tasks[].surface", { min: 1 });
+    assertStringLength(task.why, "tasks[].why", { min: 1, max: 200 });
+    assertArrayLength(task.acceptance, "tasks[].acceptance", {
+      min: 1,
+      max: 10
+    });
+    for (const criterion of task.acceptance) {
+      assertStringLength(criterion, "tasks[].acceptance[]", {
+        min: 1,
+        max: 160
+      });
+    }
+    assertStringLength(task.agentPrompt, "tasks[].agentPrompt", {
+      min: 1,
+      max: 1400
+    });
+    if (task.dependsOn) {
+      for (const dep of task.dependsOn) {
+        assertStringLength(dep, "tasks[].dependsOn[]", { min: 1 });
+      }
+    }
+  }
+  return data;
+}
+function buildRepairPrompt(error) {
+  return [
+    "Your previous output failed validation.",
+    "Fix the output and return JSON ONLY (no markdown, no commentary).",
+    "Validation error:",
+    error
+  ].join(`
+`);
+}
+function truncateText(value, maxChars) {
+  if (value.length <= maxChars)
+    return value;
+  return `${value.slice(0, maxChars)}
+...(truncated)`;
+}
+function buildRepairPromptWithOutput(error, previousOutput, maxOutputChars = 4000) {
+  return [
+    "Your previous output failed validation.",
+    "Fix the output and return JSON ONLY (no markdown, no commentary).",
+    "Do not change the JSON shape or rename fields.",
+    "If a citation quote is invalid, replace it with an exact substring from the referenced chunk.",
+    "Validation error:",
+    error,
+    "Previous output:",
+    truncateText(previousOutput, maxOutputChars)
+  ].join(`
+`);
+}
+// src/ticket-validators.ts
+import {
+  EvidenceFindingExtractionModel,
+  ProblemGroupingModel,
+  TicketCollectionModel
+} from "@contractspec/lib.contracts/product-intent/types";
+function assertStringLength2(value, path, bounds) {
+  if (bounds.min !== undefined && value.length < bounds.min) {
+    throw new Error(`Expected ${path} to be at least ${bounds.min} characters, got ${value.length}`);
+  }
+  if (bounds.max !== undefined && value.length > bounds.max) {
+    throw new Error(`Expected ${path} to be at most ${bounds.max} characters, got ${value.length}`);
+  }
+}
+function assertArrayLength2(value, path, bounds) {
+  if (bounds.min !== undefined && value.length < bounds.min) {
+    throw new Error(`Expected ${path} to have at least ${bounds.min} items, got ${value.length}`);
+  }
+  if (bounds.max !== undefined && value.length > bounds.max) {
+    throw new Error(`Expected ${path} to have at most ${bounds.max} items, got ${value.length}`);
+  }
+}
+function assertIdsExist(ids, allowed, path) {
+  for (const id of ids) {
+    if (!allowed.has(id)) {
+      throw new Error(`Unknown ${path} reference: ${id}`);
+    }
+  }
+}
+function parseJSON(schema, raw) {
+  return parseStrictJSON(schema, raw);
+}
+function validateEvidenceFindingExtraction(raw, chunks) {
+  const chunkIndex = buildChunkIndex(chunks);
+  const data = parseJSON(EvidenceFindingExtractionModel, raw);
+  assertArrayLength2(data.findings, "findings", { min: 1, max: 40 });
+  for (const finding of data.findings) {
+    assertStringLength2(finding.findingId, "findings[].findingId", { min: 1 });
+    assertStringLength2(finding.summary, "findings[].summary", {
+      min: 1,
+      max: 320
+    });
+    if (finding.tags) {
+      for (const tag of finding.tags) {
+        assertStringLength2(tag, "findings[].tags[]", { min: 1, max: 48 });
+      }
+    }
+    assertArrayLength2(finding.citations, "findings[].citations", { min: 1 });
+    for (const citation of finding.citations) {
+      validateCitation(citation, chunkIndex);
+    }
+  }
+  return data;
+}
+function validateProblemGrouping(raw, findings) {
+  const data = parseJSON(ProblemGroupingModel, raw);
+  const allowedIds = new Set(findings.map((finding) => finding.findingId));
+  assertArrayLength2(data.problems, "problems", { min: 1, max: 20 });
+  for (const problem of data.problems) {
+    assertStringLength2(problem.problemId, "problems[].problemId", { min: 1 });
+    assertStringLength2(problem.statement, "problems[].statement", {
+      min: 1,
+      max: 320
+    });
+    assertArrayLength2(problem.evidenceIds, "problems[].evidenceIds", {
+      min: 1,
+      max: 8
+    });
+    assertIdsExist(problem.evidenceIds, allowedIds, "evidenceId");
+    if (problem.tags) {
+      for (const tag of problem.tags) {
+        assertStringLength2(tag, "problems[].tags[]", { min: 1, max: 48 });
+      }
+    }
+  }
+  return data;
+}
+function validateTicketCollection(raw, findings) {
+  const data = parseJSON(TicketCollectionModel, raw);
+  const allowedIds = new Set(findings.map((finding) => finding.findingId));
+  assertArrayLength2(data.tickets, "tickets", { min: 1, max: 30 });
+  for (const ticket of data.tickets) {
+    assertStringLength2(ticket.ticketId, "tickets[].ticketId", { min: 1 });
+    assertStringLength2(ticket.title, "tickets[].title", { min: 1, max: 120 });
+    assertStringLength2(ticket.summary, "tickets[].summary", {
+      min: 1,
+      max: 320
+    });
+    assertArrayLength2(ticket.evidenceIds, "tickets[].evidenceIds", {
+      min: 1,
+      max: 8
+    });
+    assertIdsExist(ticket.evidenceIds, allowedIds, "evidenceId");
+    assertArrayLength2(ticket.acceptanceCriteria, "tickets[].acceptanceCriteria", {
+      min: 1,
+      max: 8
+    });
+    for (const criterion of ticket.acceptanceCriteria) {
+      assertStringLength2(criterion, "tickets[].acceptanceCriteria[]", {
+        min: 1,
+        max: 280
+      });
+    }
+    if (ticket.tags) {
+      for (const tag of ticket.tags) {
+        assertStringLength2(tag, "tickets[].tags[]", { min: 1, max: 48 });
+      }
+    }
+  }
+  return data;
+}
+// src/ticket-pipeline.ts
+import {
+  ContractPatchIntentModel as ContractPatchIntentModel2,
+  EvidenceFindingExtractionModel as EvidenceFindingExtractionModel2,
+  ProblemGroupingModel as ProblemGroupingModel2,
+  TicketCollectionModel as TicketCollectionModel2
+} from "@contractspec/lib.contracts/product-intent/types";
+
+// src/ticket-pipeline-runner.ts
+var DEFAULT_MAX_ATTEMPTS = 2;
+function timestamp() {
+  return new Date().toISOString();
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function safeLog(logger, entry) {
+  if (!logger)
+    return;
+  try {
+    await logger.log(entry);
+  } catch {}
+}
+async function runWithValidation(options) {
+  const maxAttempts = Math.max(1, options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+  let attempt = 0;
+  let lastError;
+  let lastRaw = "";
+  let currentPrompt = options.prompt;
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    await safeLog(options.logger, {
+      stage: options.stage,
+      phase: "request",
+      attempt,
+      prompt: currentPrompt,
+      timestamp: timestamp()
+    });
+    let raw;
+    try {
+      raw = await options.modelRunner.generateJson(currentPrompt);
+    } catch (error) {
+      lastError = toErrorMessage(error);
+      await safeLog(options.logger, {
+        stage: options.stage,
+        phase: "model_error",
+        attempt,
+        prompt: currentPrompt,
+        error: lastError,
+        timestamp: timestamp()
+      });
+      throw new Error(`[${options.stage}] Model error: ${lastError}`);
+    }
+    await safeLog(options.logger, {
+      stage: options.stage,
+      phase: "response",
+      attempt,
+      prompt: currentPrompt,
+      response: raw,
+      timestamp: timestamp()
+    });
+    try {
+      return options.validate(raw);
+    } catch (error) {
+      lastError = toErrorMessage(error);
+      lastRaw = raw;
+      if (options.repair) {
+        const repaired = options.repair(raw, lastError);
+        if (repaired && repaired !== raw) {
+          await safeLog(options.logger, {
+            stage: options.stage,
+            phase: "repair",
+            attempt,
+            prompt: currentPrompt,
+            response: repaired,
+            error: lastError,
+            timestamp: timestamp()
+          });
+          try {
+            return options.validate(repaired);
+          } catch (repairError) {
+            lastError = toErrorMessage(repairError);
+            lastRaw = repaired;
+          }
+        }
+      }
+      await safeLog(options.logger, {
+        stage: options.stage,
+        phase: "validation_error",
+        attempt,
+        prompt: currentPrompt,
+        response: lastRaw,
+        error: lastError,
+        timestamp: timestamp()
+      });
+      currentPrompt = [
+        options.prompt,
+        buildRepairPromptWithOutput(lastError, lastRaw)
+      ].join(`
+
+`);
+    }
+  }
+  throw new Error(`[${options.stage}] Validation failed after ${maxAttempts} attempt(s): ${lastError ?? "unknown error"}`);
+}
+
+// src/ticket-pipeline.ts
+var TAG_HINTS = {
+  onboarding: ["onboarding", "setup", "activation"],
+  pricing: ["pricing", "cost", "billing"],
+  security: ["security", "compliance", "audit"],
+  support: ["support", "ticket", "helpdesk"],
+  analytics: ["analytics", "report", "dashboard"],
+  performance: ["slow", "latency", "performance"],
+  integrations: ["integration", "api", "webhook"]
+};
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)+/g, "");
+}
+function pickQuote(text, maxLen = 220) {
+  const trimmed = text.trim();
+  const sentenceEnd = trimmed.search(/[.!?]\s/);
+  const sentence = sentenceEnd === -1 ? trimmed : trimmed.slice(0, sentenceEnd + 1);
+  const quote = sentence.length > maxLen ? sentence.slice(0, maxLen) : sentence;
+  return quote.trim();
+}
+function deriveTags(text) {
+  const lower = text.toLowerCase();
+  const tags = Object.entries(TAG_HINTS).filter(([, hints]) => hints.some((hint) => lower.includes(hint))).map(([tag]) => tag);
+  return tags.slice(0, 3);
+}
+function truncateToMax(value, maxChars) {
+  if (value.length <= maxChars)
+    return value;
+  if (maxChars <= 3)
+    return value.slice(0, maxChars);
+  return `${value.slice(0, maxChars - 3).trimEnd()}...`;
+}
+var QUOTE_HYPHENS = new Set(["-", "‐", "‑", "‒", "–", "—"]);
+var QUOTE_SINGLE = new Set(["'", "’", "‘"]);
+var QUOTE_DOUBLE = new Set(['"', "“", "”"]);
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildLooseQuotePattern(quote) {
+  let pattern = "";
+  for (let i = 0;i < quote.length; i += 1) {
+    const char = quote[i] ?? "";
+    if (char === "." && quote.slice(i, i + 3) === "...") {
+      pattern += "(?:\\.\\.\\.|…)";
+      i += 2;
+      continue;
+    }
+    if (char === "…") {
+      pattern += "(?:\\.\\.\\.|…)";
+      continue;
+    }
+    if (/\s/.test(char)) {
+      pattern += "\\s+";
+      while (i + 1 < quote.length && /\s/.test(quote[i + 1] ?? "")) {
+        i += 1;
+      }
+      continue;
+    }
+    if (QUOTE_HYPHENS.has(char)) {
+      pattern += "[-‐‑‒–—]";
+      continue;
+    }
+    if (QUOTE_SINGLE.has(char)) {
+      pattern += "['‘’]";
+      continue;
+    }
+    if (QUOTE_DOUBLE.has(char)) {
+      pattern += '["“”]';
+      continue;
+    }
+    pattern += escapeRegex(char);
+  }
+  return pattern;
+}
+function findQuoteInChunk(quote, chunkText) {
+  if (chunkText.includes(quote))
+    return quote;
+  const pattern = buildLooseQuotePattern(quote);
+  const match = chunkText.match(new RegExp(pattern));
+  return match?.[0] ?? null;
+}
+function normalizeForTokens(value) {
+  return value.replace(/[“”]/g, '"').replace(/[‘’]/g, "'").replace(/[‐‑‒–—]/g, "-").replace(/\s+/g, " ").trim();
+}
+function tokenize(value) {
+  const normalized = normalizeForTokens(value).toLowerCase();
+  return normalized.match(/[a-z0-9]+/g) ?? [];
+}
+function splitIntoSegments(text) {
+  const matches = text.match(/[^.!?\n]+[.!?]?/g);
+  if (!matches)
+    return [text];
+  return matches.map((segment) => segment.trim()).filter(Boolean);
+}
+function selectBestQuoteFromChunk(quote, chunkText, maxLen = 240) {
+  const quoteTokens = tokenize(quote);
+  if (!quoteTokens.length)
+    return null;
+  const quoteTokenSet = new Set(quoteTokens);
+  let best = null;
+  for (const segment of splitIntoSegments(chunkText)) {
+    if (!segment)
+      continue;
+    const segmentTokens = new Set(tokenize(segment));
+    if (!segmentTokens.size)
+      continue;
+    let overlap = 0;
+    for (const token of quoteTokenSet) {
+      if (segmentTokens.has(token))
+        overlap += 1;
+    }
+    if (!overlap)
+      continue;
+    const score = overlap / quoteTokenSet.size;
+    if (!best || score > best.score) {
+      best = { segment, score, overlap };
+    }
+  }
+  if (!best)
+    return null;
+  if (best.overlap < 2 && quoteTokens.length > 2)
+    return null;
+  const trimmed = best.segment.trim();
+  return trimmed.length > maxLen ? trimmed.slice(0, maxLen).trimEnd() : trimmed;
+}
+function fallbackQuoteFromChunk(chunkText, maxLen = 240) {
+  const trimmed = chunkText.trim();
+  if (!trimmed)
+    return null;
+  const slice = trimmed.length > maxLen ? trimmed.slice(0, maxLen) : trimmed;
+  return slice.trimEnd();
+}
+function findQuoteAcrossChunks(quote, chunkIndex) {
+  for (const [chunkId, chunk] of chunkIndex.entries()) {
+    if (chunk.text.includes(quote)) {
+      return { chunkId, quote };
+    }
+    const repaired = findQuoteInChunk(quote, chunk.text);
+    if (repaired) {
+      return { chunkId, quote: repaired };
+    }
+  }
+  return null;
+}
+function repairEvidenceFindingExtraction(raw, chunks) {
+  let data;
+  try {
+    data = parseStrictJSON(EvidenceFindingExtractionModel2, raw);
+  } catch {
+    return null;
+  }
+  const chunkIndex = buildChunkIndex(chunks);
+  let updated = false;
+  for (const finding of data.findings) {
+    for (const citation of finding.citations) {
+      const chunk = chunkIndex.get(citation.chunkId);
+      if (chunk) {
+        if (chunk.text.includes(citation.quote))
+          continue;
+        const repaired = findQuoteInChunk(citation.quote, chunk.text);
+        if (repaired) {
+          citation.quote = repaired;
+          updated = true;
+          continue;
+        }
+      }
+      const other = findQuoteAcrossChunks(citation.quote, chunkIndex);
+      if (other) {
+        citation.chunkId = other.chunkId;
+        citation.quote = other.quote;
+        updated = true;
+        continue;
+      }
+      if (chunk) {
+        const best = selectBestQuoteFromChunk(citation.quote, chunk.text);
+        if (best) {
+          citation.quote = best;
+          updated = true;
+          continue;
+        }
+        const fallback = fallbackQuoteFromChunk(chunk.text);
+        if (fallback) {
+          citation.quote = fallback;
+          updated = true;
+          continue;
+        }
+      }
+    }
+  }
+  return updated ? JSON.stringify(data, null, 2) : null;
+}
+function repairProblemGrouping(raw) {
+  let data;
+  try {
+    data = parseStrictJSON(ProblemGroupingModel2, raw);
+  } catch {
+    return null;
+  }
+  let updated = false;
+  for (const problem of data.problems) {
+    const statement = truncateToMax(problem.statement, 320);
+    if (statement !== problem.statement) {
+      problem.statement = statement;
+      updated = true;
+    }
+  }
+  return updated ? JSON.stringify(data, null, 2) : null;
+}
+function repairTicketCollection(raw) {
+  let data;
+  try {
+    data = parseStrictJSON(TicketCollectionModel2, raw);
+  } catch {
+    return null;
+  }
+  let updated = false;
+  for (const ticket of data.tickets) {
+    const title = truncateToMax(ticket.title, 120);
+    const summary = truncateToMax(ticket.summary, 320);
+    if (title !== ticket.title) {
+      ticket.title = title;
+      updated = true;
+    }
+    if (summary !== ticket.summary) {
+      ticket.summary = summary;
+      updated = true;
+    }
+    ticket.acceptanceCriteria = ticket.acceptanceCriteria.map((criterion) => {
+      const next = truncateToMax(criterion, 160);
+      if (next !== criterion)
+        updated = true;
+      return next;
+    });
+  }
+  return updated ? JSON.stringify(data, null, 2) : null;
+}
+function repairPatchIntent(raw) {
+  let data;
+  try {
+    data = parseStrictJSON(ContractPatchIntentModel2, raw);
+  } catch {
+    return null;
+  }
+  let updated = false;
+  const featureKey = truncateToMax(data.featureKey, 80);
+  if (featureKey !== data.featureKey) {
+    data.featureKey = featureKey;
+    updated = true;
+  }
+  data.acceptanceCriteria = data.acceptanceCriteria.map((criterion) => {
+    const next = truncateToMax(criterion, 140);
+    if (next !== criterion)
+      updated = true;
+    return next;
+  });
+  return updated ? JSON.stringify(data, null, 2) : null;
+}
+function retrieveChunks(transcript, question, options = {}) {
+  const chunkSize = options.chunkSize ?? 800;
+  const sourceId = options.sourceId ?? slugify(question || "transcript");
+  const clean = transcript.trim();
+  const chunks = [];
+  for (let offset = 0, idx = 0;offset < clean.length; idx += 1) {
+    const slice = clean.slice(offset, offset + chunkSize);
+    chunks.push({
+      chunkId: `${sourceId}#c_${String(idx).padStart(2, "0")}`,
+      text: slice,
+      meta: { sourceId, ...options.meta }
+    });
+    offset += chunkSize;
+  }
+  return chunks;
+}
+async function extractEvidence(chunks, question, options = {}) {
+  if (options.modelRunner) {
+    const evidenceJSON = formatEvidenceForModel(chunks, 900);
+    const prompt = promptExtractEvidenceFindings({ question, evidenceJSON });
+    return runWithValidation({
+      stage: "extractEvidence",
+      prompt,
+      modelRunner: options.modelRunner,
+      logger: options.logger,
+      maxAttempts: options.maxAttempts,
+      repair: (raw2) => repairEvidenceFindingExtraction(raw2, chunks),
+      validate: (raw2) => validateEvidenceFindingExtraction(raw2, chunks).findings
+    });
+  }
+  const maxFindings = options.maxFindings ?? 12;
+  const findings = [];
+  for (const chunk of chunks) {
+    if (findings.length >= maxFindings)
+      break;
+    const quote = pickQuote(chunk.text);
+    findings.push({
+      findingId: `find_${String(findings.length + 1).padStart(3, "0")}`,
+      summary: quote.length > 160 ? `${quote.slice(0, 160)}...` : quote,
+      tags: deriveTags(chunk.text),
+      citations: [{ chunkId: chunk.chunkId, quote }]
+    });
+  }
+  const raw = JSON.stringify({ findings }, null, 2);
+  return validateEvidenceFindingExtraction(raw, chunks).findings;
+}
+async function groupProblems(findings, question, options = {}) {
+  if (options.modelRunner) {
+    const findingsJSON = JSON.stringify({ findings }, null, 2);
+    const prompt = promptGroupProblems({
+      question,
+      findingsJSON,
+      findingIds: findings.map((finding) => finding.findingId)
+    });
+    return runWithValidation({
+      stage: "groupProblems",
+      prompt,
+      modelRunner: options.modelRunner,
+      logger: options.logger,
+      maxAttempts: options.maxAttempts,
+      repair: (raw2) => repairProblemGrouping(raw2),
+      validate: (raw2) => validateProblemGrouping(raw2, findings).problems
+    });
+  }
+  const grouped = new Map;
+  for (const finding of findings) {
+    const tag = finding.tags?.[0] ?? "general";
+    if (!grouped.has(tag))
+      grouped.set(tag, []);
+    grouped.get(tag)?.push(finding);
+  }
+  const problems = [];
+  for (const [tag, items] of grouped.entries()) {
+    const count = items.length;
+    const severity = count >= 4 ? "high" : count >= 2 ? "medium" : "low";
+    const statement = tag === "general" ? "Users report friction that slows adoption." : `Users report ${tag} friction that blocks progress.`;
+    problems.push({
+      problemId: `prob_${String(problems.length + 1).padStart(3, "0")}`,
+      statement,
+      evidenceIds: items.map((item) => item.findingId),
+      tags: tag === "general" ? undefined : [tag],
+      severity
+    });
+  }
+  const raw = JSON.stringify({ problems }, null, 2);
+  return validateProblemGrouping(raw, findings).problems;
+}
+async function generateTickets(problems, findings, question, options = {}) {
+  if (options.modelRunner) {
+    const problemsJSON = JSON.stringify({ problems }, null, 2);
+    const findingsJSON = JSON.stringify({ findings }, null, 2);
+    const prompt = promptGenerateTickets({
+      question,
+      problemsJSON,
+      findingsJSON
+    });
+    return runWithValidation({
+      stage: "generateTickets",
+      prompt,
+      modelRunner: options.modelRunner,
+      logger: options.logger,
+      maxAttempts: options.maxAttempts,
+      repair: (raw2) => repairTicketCollection(raw2),
+      validate: (raw2) => validateTicketCollection(raw2, findings).tickets
+    });
+  }
+  const tickets = problems.map((problem, idx) => {
+    const tag = problem.tags?.[0];
+    const title = tag ? `Improve ${tag} flow` : "Reduce user friction";
+    const summary = problem.statement;
+    return {
+      ticketId: `t_${String(idx + 1).padStart(3, "0")}`,
+      title,
+      summary,
+      evidenceIds: problem.evidenceIds.slice(0, 4),
+      acceptanceCriteria: [
+        "Acceptance criteria maps to the evidence findings",
+        "Success metrics are tracked for the change"
+      ],
+      tags: problem.tags,
+      priority: problem.severity === "high" ? "high" : "medium"
+    };
+  });
+  const raw = JSON.stringify({ tickets }, null, 2);
+  return validateTicketCollection(raw, findings).tickets;
+}
+async function suggestPatch(ticket, options = {}) {
+  if (options.modelRunner) {
+    const ticketJSON = JSON.stringify(ticket, null, 2);
+    const prompt = promptSuggestPatchIntent({ ticketJSON });
+    return runWithValidation({
+      stage: "suggestPatch",
+      prompt,
+      modelRunner: options.modelRunner,
+      logger: options.logger,
+      maxAttempts: options.maxAttempts,
+      repair: (raw) => repairPatchIntent(raw),
+      validate: (raw) => validatePatchIntent(raw)
+    });
+  }
+  const featureKey = slugify(ticket.title) || "product_intent_ticket";
+  const intent = {
+    featureKey,
+    changes: [
+      {
+        type: "update_operation",
+        target: `productIntent.${featureKey}`,
+        detail: ticket.summary
+      }
+    ],
+    acceptanceCriteria: ticket.acceptanceCriteria
+  };
+  return validatePatchIntent(JSON.stringify(intent, null, 2));
+}
+// src/impact-engine.ts
+var SURFACE_MAP = {
+  add_field: ["api", "db", "ui", "docs", "tests"],
+  remove_field: ["api", "db", "ui", "docs", "tests"],
+  rename_field: ["api", "db", "ui", "docs", "tests"],
+  add_event: ["api", "workflows", "docs", "tests"],
+  update_event: ["api", "workflows", "docs", "tests"],
+  add_operation: ["api", "ui", "workflows", "docs", "tests"],
+  update_operation: ["api", "ui", "workflows", "docs", "tests"],
+  update_form: ["ui", "docs", "tests"],
+  update_policy: ["policy", "api", "workflows", "docs", "tests"],
+  add_enum_value: ["api", "db", "ui", "docs", "tests"],
+  remove_enum_value: ["api", "db", "ui", "docs", "tests"],
+  other: ["docs", "tests"]
+};
+var BUCKET_MAP = {
+  remove_field: "breaks",
+  rename_field: "breaks",
+  remove_enum_value: "breaks",
+  update_operation: "mustChange",
+  update_event: "mustChange",
+  update_policy: "mustChange",
+  update_form: "risky",
+  add_field: "risky",
+  add_event: "risky",
+  add_operation: "risky",
+  add_enum_value: "risky",
+  other: "risky"
+};
+function slugify2(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)+/g, "");
+}
+function buildTokens(change) {
+  const combined = `${change.type} ${change.target} ${change.detail}`;
+  const tokens = combined.split(/[^a-zA-Z0-9]+/).map((token) => token.trim()).filter((token) => token.length >= 3);
+  return Array.from(new Set(tokens.map((token) => token.toLowerCase()))).slice(0, 8);
+}
+function scanTokens(tokens, files, maxHits) {
+  const hits = [];
+  const lowerTokens = tokens.map((token) => token.toLowerCase());
+  for (const file of files) {
+    const haystack = file.content.toLowerCase();
+    if (lowerTokens.some((token) => haystack.includes(token))) {
+      hits.push(file.path);
+    }
+    if (hits.length >= maxHits)
+      break;
+  }
+  return hits;
+}
+function formatRefs(tokens, repoFiles, maxHits = 3) {
+  if (!repoFiles || repoFiles.length === 0) {
+    return "refs: (no repo scan)";
+  }
+  const hits = scanTokens(tokens, repoFiles, maxHits);
+  if (!hits.length)
+    return "refs: none";
+  return `refs: ${hits.join(", ")}`;
+}
+function humanizeChange(change) {
+  const label = change.type.replace(/_/g, " ");
+  return `${label} ${change.target}`;
+}
+function buildStatement(change, refs, surfaces) {
+  const reason = change.detail || `touches ${surfaces.join(", ")}`;
+  return `${humanizeChange(change)} because ${reason} (${refs})`;
+}
+function impactEngine(intent, options = {}) {
+  const reportId = options.reportId ?? `impact-${slugify2(intent.featureKey)}`;
+  const patchId = options.patchId ?? `patch-${slugify2(intent.featureKey)}`;
+  const maxHitsPerChange = options.maxHitsPerChange ?? 3;
+  const breaks = [];
+  const mustChange = [];
+  const risky = [];
+  const surfaces = {
+    api: [],
+    db: [],
+    ui: [],
+    workflows: [],
+    policy: [],
+    docs: [],
+    tests: []
+  };
+  for (const change of intent.changes) {
+    const bucket = BUCKET_MAP[change.type] ?? "risky";
+    const surfaceTargets = SURFACE_MAP[change.type] ?? ["docs", "tests"];
+    const tokens = buildTokens(change);
+    const refs = formatRefs(tokens, options.repoFiles, maxHitsPerChange);
+    const statement = buildStatement(change, refs, surfaceTargets);
+    if (bucket === "breaks")
+      breaks.push(statement);
+    if (bucket === "mustChange")
+      mustChange.push(statement);
+    if (bucket === "risky")
+      risky.push(statement);
+    for (const surface of surfaceTargets) {
+      const list = surfaces[surface];
+      if (Array.isArray(list)) {
+        list.push(statement);
+      }
+    }
+  }
+  const summary = [
+    `Analyzed ${intent.changes.length} change(s).`,
+    `Breaks: ${breaks.length}.`,
+    `Must change: ${mustChange.length}.`,
+    `Risky: ${risky.length}.`
+  ].join(" ");
+  return {
+    reportId,
+    patchId,
+    summary,
+    breaks,
+    mustChange,
+    risky,
+    surfaces
+  };
+}
+// src/project-management-sync.ts
+function buildProjectManagementSyncPayload(params) {
+  const options = params.options ?? {};
+  const items = buildWorkItemsFromTickets(params.tickets, options);
+  const summary = options.includeSummary ? buildSummaryWorkItem({
+    question: params.question,
+    tickets: params.tickets,
+    patchIntent: params.patchIntent,
+    impact: params.impact,
+    title: options.summaryTitle,
+    baseTags: options.baseTags
+  }) : undefined;
+  return { summary, items };
+}
+function buildWorkItemsFromTickets(tickets, options = {}) {
+  return tickets.map((ticket) => ({
+    title: ticket.title,
+    description: renderTicketDescription(ticket),
+    type: "task",
+    priority: mapPriority(ticket.priority, options.defaultPriority),
+    tags: mergeTags(options.baseTags, ticket.tags),
+    externalId: ticket.ticketId
+  }));
+}
+function buildSummaryWorkItem(params) {
+  return {
+    title: params.title ?? "Product Intent Summary",
+    description: renderSummaryMarkdown(params),
+    type: "summary",
+    tags: mergeTags(params.baseTags, ["product-intent", "summary"])
+  };
+}
+function renderTicketDescription(ticket) {
+  const lines = [
+    ticket.summary,
+    "",
+    "Acceptance Criteria:",
+    ...ticket.acceptanceCriteria.map((criterion) => `- ${criterion}`)
+  ];
+  if (ticket.evidenceIds.length > 0) {
+    lines.push("", `Evidence: ${ticket.evidenceIds.join(", ")}`);
+  }
+  return lines.join(`
+`);
+}
+function renderSummaryMarkdown(params) {
+  const lines = [`# ${params.question}`, "", "## Top Tickets"];
+  for (const ticket of params.tickets) {
+    lines.push(`- ${ticket.title}`);
+  }
+  if (params.patchIntent) {
+    lines.push("", "## Patch Intent", `Feature: ${params.patchIntent.featureKey}`);
+    params.patchIntent.changes.forEach((change) => {
+      lines.push(`- ${change.type}: ${change.target}`);
+    });
+  }
+  if (params.impact) {
+    lines.push("", "## Impact Summary", params.impact.summary);
+  }
+  return lines.join(`
+`);
+}
+function mapPriority(priority, fallback) {
+  if (!priority)
+    return fallback;
+  switch (priority) {
+    case "high":
+      return "high";
+    case "medium":
+      return "medium";
+    case "low":
+      return "low";
+    default:
+      return fallback;
+  }
+}
+function mergeTags(baseTags, tags) {
+  const merged = new Set;
+  (baseTags ?? []).forEach((tag) => merged.add(tag));
+  (tags ?? []).forEach((tag) => merged.add(tag));
+  const result = [...merged];
+  return result.length > 0 ? result : undefined;
+}
+export {
+  validateTicketCollection,
+  validateTaskPack,
+  validateProblemGrouping,
+  validatePatchIntent,
+  validateOpportunityBrief,
+  validateInsightExtraction,
+  validateImpactReport,
+  validateEvidenceFindingExtraction,
+  validateCitationsInTextBlock,
+  validateCitation,
+  suggestPatch,
+  runWithValidation,
+  retrieveChunks,
+  promptWireframeLayoutJSON,
+  promptWireframeImage,
+  promptSynthesizeBrief,
+  promptSuggestPatchIntent,
+  promptSkepticCheck,
+  promptGroupProblems,
+  promptGenerateTickets,
+  promptGenerateTaskPack,
+  promptGenerateSyntheticInterviews,
+  promptGeneratePatchIntent,
+  promptGenerateImpactReport,
+  promptGenerateGenericSpecOverlay,
+  promptExtractInsights,
+  promptExtractEvidenceFindings,
+  parseStrictJSON,
+  impactEngine,
+  groupProblems,
+  generateTickets,
+  formatEvidenceForModel,
+  extractEvidence,
+  buildWorkItemsFromTickets,
+  buildRepairPromptWithOutput,
+  buildRepairPrompt,
+  buildProjectManagementSyncPayload,
+  buildChunkIndex,
+  JSON_ONLY_RULES,
+  CITATION_RULES
+};