@contractspec/lib.contracts-spec 2.0.0

package/dist/product-intent/tickets.js

@@ -0,0 +1,57 @@
+// @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/product-intent/tickets.ts
+import { ZodSchemaType } from "@contractspec/lib.schema";
+import * as z from "zod";
+var TicketPrioritySchema = z.enum(["low", "medium", "high"]);
+var TicketSchema = z.object({
+  ticketId: z.string().min(1),
+  title: z.string().min(1),
+  summary: z.string().min(1),
+  evidenceIds: z.array(z.string().min(1)).min(1),
+  acceptanceCriteria: z.array(z.string().min(1)).min(1),
+  priority: TicketPrioritySchema.optional(),
+  tags: z.array(z.string().min(1)).optional()
+});
+var TicketModel = new ZodSchemaType(TicketSchema, {
+  name: "Ticket"
+});
+var TicketCollectionSchema = z.object({
+  tickets: z.array(TicketSchema)
+});
+var TicketCollectionModel = new ZodSchemaType(TicketCollectionSchema, {
+  name: "TicketCollection"
+});
+export {
+  TicketModel,
+  TicketCollectionModel
+};

package/dist/product-intent/types.d.ts

@@ -0,0 +1,11 @@
+export * from './evidence';
+export * from './findings';
+export * from './insights';
+export * from './problems';
+export * from './opportunity-brief';
+export * from './contract-patch-intent';
+export * from './contract-spec-patch';
+export * from './impact-report';
+export * from './task-pack';
+export * from './tickets';
+export * from './ui-wireframe';

package/dist/product-intent/types.js

@@ -0,0 +1,378 @@
+// @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/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"
+});
+export {
+  UiWireframeRequestModel,
+  UiWireframeLayoutModel,
+  UiWireframeElementModel,
+  TicketModel,
+  TicketCollectionModel,
+  TaskPackModel,
+  TaskModel,
+  RiskModel,
+  ProblemStatementModel,
+  ProblemGroupingModel,
+  PatchChangeModel,
+  OpportunityBriefModel,
+  InsightModel,
+  InsightExtractionModel,
+  ImpactSurfacesModel,
+  ImpactReportModel,
+  ExpectedImpactModel,
+  EvidenceFindingModel,
+  EvidenceFindingExtractionModel,
+  EvidenceChunkModel,
+  ContractSpecPatchModel,
+  ContractSpecOverlayModel,
+  ContractPatchUpdateModel,
+  ContractPatchRemoveModel,
+  ContractPatchIntentModel,
+  ContractPatchAddModel,
+  CitedTextBlockModel,
+  CitationModel
+};

package/dist/product-intent/ui-wireframe.d.ts

@@ -0,0 +1,100 @@
+import { ZodSchemaType } from '@contractspec/lib.schema';
+import * as z from 'zod';
+declare const WireframeDeviceSchema: z.ZodEnum<{
+    mobile: "mobile";
+    desktop: "desktop";
+}>;
+export type WireframeDevice = z.infer<typeof WireframeDeviceSchema>;
+declare const WireframeElementTypeSchema: z.ZodEnum<{
+    list: "list";
+    text: "text";
+    card: "card";
+    input: "input";
+    button: "button";
+    header: "header";
+    progress: "progress";
+    divider: "divider";
+}>;
+export type WireframeElementType = z.infer<typeof WireframeElementTypeSchema>;
+declare const UiWireframeRequestSchema: z.ZodObject<{
+    screenName: z.ZodString;
+    device: z.ZodEnum<{
+        mobile: "mobile";
+        desktop: "desktop";
+    }>;
+    currentScreenSummary: z.ZodString;
+    proposedChanges: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const UiWireframeRequestModel: ZodSchemaType<z.ZodObject<{
+    screenName: z.ZodString;
+    device: z.ZodEnum<{
+        mobile: "mobile";
+        desktop: "desktop";
+    }>;
+    currentScreenSummary: z.ZodString;
+    proposedChanges: z.ZodArray<z.ZodString>;
+}, z.core.$strip>>;
+export type UiWireframeRequest = z.infer<typeof UiWireframeRequestSchema>;
+declare const UiWireframeElementSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        list: "list";
+        text: "text";
+        card: "card";
+        input: "input";
+        button: "button";
+        header: "header";
+        progress: "progress";
+        divider: "divider";
+    }>;
+    label: z.ZodString;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const UiWireframeElementModel: ZodSchemaType<z.ZodObject<{
+    type: z.ZodEnum<{
+        list: "list";
+        text: "text";
+        card: "card";
+        input: "input";
+        button: "button";
+        header: "header";
+        progress: "progress";
+        divider: "divider";
+    }>;
+    label: z.ZodString;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export type UiWireframeElement = z.infer<typeof UiWireframeElementSchema>;
+declare const UiWireframeLayoutSchema: z.ZodObject<{
+    layout: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            list: "list";
+            text: "text";
+            card: "card";
+            input: "input";
+            button: "button";
+            header: "header";
+            progress: "progress";
+            divider: "divider";
+        }>;
+        label: z.ZodString;
+        notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const UiWireframeLayoutModel: ZodSchemaType<z.ZodObject<{
+    layout: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            list: "list";
+            text: "text";
+            card: "card";
+            input: "input";
+            button: "button";
+            header: "header";
+            progress: "progress";
+            divider: "divider";
+        }>;
+        label: z.ZodString;
+        notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+export type UiWireframeLayout = z.infer<typeof UiWireframeLayoutSchema>;
+export {};

package/dist/product-intent/ui-wireframe.js

@@ -0,0 +1,73 @@
+// @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/product-intent/ui-wireframe.ts
+import { ZodSchemaType } from "@contractspec/lib.schema";
+import * as z from "zod";
+var WireframeDeviceSchema = z.enum(["mobile", "desktop"]);
+var WireframeElementTypeSchema = z.enum([
+  "header",
+  "text",
+  "input",
+  "button",
+  "list",
+  "card",
+  "divider",
+  "progress"
+]);
+var UiWireframeRequestSchema = z.object({
+  screenName: z.string().min(1),
+  device: WireframeDeviceSchema,
+  currentScreenSummary: z.string().min(1),
+  proposedChanges: z.array(z.string().min(1))
+});
+var UiWireframeRequestModel = new ZodSchemaType(UiWireframeRequestSchema, {
+  name: "UiWireframeRequest"
+});
+var UiWireframeElementSchema = z.object({
+  type: WireframeElementTypeSchema,
+  label: z.string().min(1),
+  notes: z.string().min(1).optional()
+});
+var UiWireframeElementModel = new ZodSchemaType(UiWireframeElementSchema, {
+  name: "UiWireframeElement"
+});
+var UiWireframeLayoutSchema = z.object({
+  layout: z.array(UiWireframeElementSchema)
+});
+var UiWireframeLayoutModel = new ZodSchemaType(UiWireframeLayoutSchema, {
+  name: "UiWireframeLayout"
+});
+export {
+  UiWireframeRequestModel,
+  UiWireframeLayoutModel,
+  UiWireframeElementModel
+};

package/dist/prompt.d.ts

@@ -0,0 +1,49 @@
+import * as z from 'zod';
+import { type OwnerShipMeta } from './ownership';
+export type PromptStability = 'experimental' | 'beta' | 'stable' | 'deprecated';
+/** Parameter definition for a prompt argument. */
+export interface PromptArg {
+    name: string;
+    description?: string;
+    required?: boolean;
+    schema: z.ZodType;
+    completeWith?: string;
+}
+/**
+ * Rendered content part for a prompt. Clients (MCP) can fetch referenced resources.
+ */
+export type PromptContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'resource';
+    uri: string;
+    title?: string;
+};
+/** Prompt metadata for discoverability and governance. */
+export type PromptMeta = OwnerShipMeta;
+/** Policy constraints for prompts (flags, PII paths, rate limits). */
+export interface PromptPolicy {
+    flags?: string[];
+    pii?: string[];
+    rateLimit?: {
+        rpm: number;
+        key: 'user' | 'org' | 'global';
+    };
+}
+/** Full prompt specification including args schema and render function. */
+export interface PromptSpec<I extends z.ZodType> {
+    meta: PromptMeta;
+    args: PromptArg[];
+    input: I;
+    policy?: PromptPolicy;
+    /** Render MCP-friendly content parts. DO NOT perform side effects here. */
+    render: (args: z.infer<I>, ctx: {
+        userId?: string | null;
+        orgId?: string | null;
+        locale?: string;
+        link: (template: string, vars: Record<string, string | number>) => string;
+    }) => Promise<PromptContentPart[]>;
+}
+/** Identity helper that preserves generic inference when declaring prompts. */
+export declare function definePrompt<I extends z.ZodType>(spec: PromptSpec<I>): PromptSpec<I>;