@usefragments/core 1.11.0 → 2.0.0

package/src/feature-plan/types.ts

@@ -1,628 +0,0 @@
-import { z } from "zod";
-import {
-  digestHexStringSchema,
-  featurePlanIdStringSchema,
-  featureRevisionIdStringSchema,
-  type FeaturePlanId,
-  type FeatureRevisionId,
-} from "../domain-ids.js";
-
-export const FEATURE_PLAN_MAX_EVIDENCE_REFS_V1 = 200;
-export const FEATURE_PLAN_MAX_USES_PER_KIND_V1 = 100;
-export const FEATURE_PLAN_MAX_GAPS_V1 = 50;
-export const FEATURE_PLAN_MAX_DECISIONS_V1 = 50;
-export const FEATURE_PLAN_MAX_SCENARIOS_V1 = 50;
-export const FEATURE_PLAN_MAX_ACCEPTANCE_ITEMS_V1 = 100;
-export const FEATURE_PLAN_MAX_TEXT_BYTES_V1 = 32 * 1024;
-export const AGENT_FEATURE_CONTEXT_MAX_BYTES_V1 = 64 * 1024;
-
-const utf8Length = (value: string): number => new TextEncoder().encode(value).byteLength;
-const boundedString = (maxBytes = FEATURE_PLAN_MAX_TEXT_BYTES_V1) =>
-  z
-    .string()
-    .min(1)
-    .refine((value) => utf8Length(value) <= maxBytes, `Value exceeds ${maxBytes} UTF-8 bytes`);
-const shortString = () => boundedString(4_096);
-const unique = (values: readonly string[]): boolean => new Set(values).size === values.length;
-const uniqueIdArray = (max = FEATURE_PLAN_MAX_EVIDENCE_REFS_V1) =>
-  z.array(shortString()).max(max).refine(unique, "ID references must be unique");
-
-export const evidenceRefV1Schema = z
-  .object({
-    evidenceId: shortString(),
-    kind: z.enum(["user_intent", "image", "source", "contract", "pattern", "model"]),
-    authority: z.enum(["user_asserted", "source_observed", "contract_approved", "model_inferred"]),
-    ref: boundedString(),
-    digest: digestHexStringSchema,
-  })
-  .strict();
-
-export const placementDecisionV1Schema = z
-  .object({
-    targetKind: z.enum(["page", "section"]),
-    targetRef: shortString(),
-    routeRef: shortString().optional(),
-    parentSlotRef: shortString(),
-    evidenceRefIds: uniqueIdArray(),
-  })
-  .strict();
-
-const propValueSchema = z.union([boundedString(), z.number().finite(), z.boolean(), z.null()]);
-export const componentUseDecisionV1Schema = z
-  .object({
-    useId: shortString(),
-    componentId: shortString(),
-    importPath: shortString(),
-    purpose: boundedString(),
-    props: z
-      .record(shortString(), propValueSchema)
-      .refine((props) => Object.keys(props).length <= 100, "Component props exceed V1 limit"),
-    evidenceRefIds: uniqueIdArray(),
-  })
-  .strict();
-
-export const tokenUseDecisionV1Schema = z
-  .object({
-    useId: shortString(),
-    tokenId: shortString(),
-    role: shortString(),
-    evidenceRefIds: uniqueIdArray(),
-  })
-  .strict();
-
-export const patternStatusV1Schema = z.enum([
-  "observed",
-  "candidate",
-  "approved_guidance",
-  "contract_canonical",
-  "deprecated",
-]);
-export const patternUseDecisionV1Schema = z
-  .object({
-    useId: shortString(),
-    patternId: shortString(),
-    patternRevisionDigest: digestHexStringSchema,
-    status: patternStatusV1Schema,
-    disposition: z.enum(["reuse", "reference", "reject"]),
-    evidenceRefIds: uniqueIdArray(),
-  })
-  .strict()
-  .superRefine((pattern, context) => {
-    if (
-      pattern.disposition === "reuse" &&
-      pattern.status !== "approved_guidance" &&
-      pattern.status !== "contract_canonical"
-    ) {
-      context.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["disposition"],
-        message: "Only approved-guidance or contract-canonical patterns may be reused",
-      });
-    }
-  });
-
-export const layoutConcernV1Schema = z.enum([
-  "outer_inline_spacing",
-  "outer_block_spacing",
-  "inner_padding",
-  "child_gap",
-  "max_inline_size",
-  "scroll_x",
-  "scroll_y",
-  "sticky_offset",
-  "breakpoint_switching",
-]);
-const layoutConcernOwnerV1Schema = z
-  .object({
-    concern: layoutConcernV1Schema,
-    ownerLayer: z.enum([
-      "application_shell",
-      "route_shell",
-      "page",
-      "section",
-      "pattern",
-      "primitive",
-    ]),
-    ownerRef: shortString(),
-    childAction: z.enum(["consume", "own", "override"]),
-    tokenRef: shortString().optional(),
-    breakpointRef: shortString().optional(),
-    evidenceRefIds: uniqueIdArray(),
-    overrideDecisionId: shortString().optional(),
-  })
-  .strict()
-  .superRefine((row, context) => {
-    if (row.childAction === "override" && !row.overrideDecisionId) {
-      context.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["overrideDecisionId"],
-        message: "A layout override must reference an approved decision",
-      });
-    }
-    if (row.childAction !== "override" && row.overrideDecisionId) {
-      context.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["overrideDecisionId"],
-        message: "Only an override may reference an override decision",
-      });
-    }
-  });
-export const layoutOwnershipV1Schema = z
-  .object({
-    concerns: z
-      .array(layoutConcernOwnerV1Schema)
-      .max(32)
-      .refine(
-        (rows) => new Set(rows.map((row) => row.concern)).size === rows.length,
-        "Each layout concern must have exactly one owner"
-      ),
-  })
-  .strict();
-
-export const responsiveDecisionV1Schema = z
-  .object({
-    decisionId: shortString(),
-    source: z.enum(["contract", "observed", "desktop_only"]),
-    breakpointRef: shortString().optional(),
-    behavior: boundedString(),
-    evidenceRefIds: uniqueIdArray(),
-  })
-  .strict()
-  .superRefine((decision, context) => {
-    if (decision.source !== "desktop_only" && !decision.breakpointRef) {
-      context.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["breakpointRef"],
-        message: "Responsive contract/observed decisions must pin a breakpoint",
-      });
-    }
-  });
-
-export const scenarioRequirementV1Schema = z
-  .object({
-    scenarioId: shortString(),
-    viewportRef: shortString().optional(),
-    themeRef: shortString().optional(),
-    actorRole: shortString().optional(),
-    dataState: z.enum(["default", "loading", "empty", "partial", "error"]),
-    interactionState: z
-      .enum(["pristine", "dirty", "validating", "saving", "saved", "disabled"])
-      .optional(),
-    acceptanceIds: uniqueIdArray(FEATURE_PLAN_MAX_ACCEPTANCE_ITEMS_V1),
-  })
-  .strict();
-
-export const gapDispositionV1Schema = z.enum([
-  "canonical_reuse",
-  "approved_pattern",
-  "local_composition",
-  "intentional_one_off",
-  "proposed_contract_addition",
-  "unresolved",
-]);
-export const capabilityGapV1Schema = z
-  .object({
-    gapId: shortString(),
-    capability: boundedString(),
-    required: z.boolean(),
-    disposition: gapDispositionV1Schema,
-    reason: boundedString(),
-    evidenceRefIds: uniqueIdArray(),
-    proposedContractCandidateId: shortString().optional(),
-  })
-  .strict()
-  .superRefine((gap, context) => {
-    if (gap.disposition === "proposed_contract_addition" && !gap.proposedContractCandidateId) {
-      context.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["proposedContractCandidateId"],
-        message: "A proposed contract addition must pin its candidate",
-      });
-    }
-    if (gap.disposition !== "proposed_contract_addition" && gap.proposedContractCandidateId) {
-      context.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["proposedContractCandidateId"],
-        message: "Only a proposed contract addition may carry a candidate ID",
-      });
-    }
-  });
-
-export const featureAcceptanceItemV1Schema = z
-  .object({
-    acceptanceId: shortString(),
-    statement: boundedString(),
-    proof: z.enum(["unit", "integration", "browser", "governance", "manual"]),
-    required: z.boolean(),
-    evidenceRefIds: uniqueIdArray(),
-  })
-  .strict();
-
-const decisionOptionV1Schema = z
-  .object({ optionId: shortString(), label: boundedString(), consequence: boundedString() })
-  .strict();
-export const decisionRequestV1Schema = z
-  .object({
-    decisionId: shortString(),
-    kind: z.enum(["placement", "reuse", "gap", "layout_override", "responsive", "scope"]),
-    question: boundedString(),
-    options: z
-      .array(decisionOptionV1Schema)
-      .min(2)
-      .max(20)
-      .refine(
-        (options) => new Set(options.map((option) => option.optionId)).size === options.length,
-        "Decision option IDs must be unique"
-      ),
-    recommendedOptionId: shortString().optional(),
-    required: z.boolean(),
-    evidenceRefIds: uniqueIdArray(),
-  })
-  .strict()
-  .superRefine((decision, context) => {
-    if (
-      decision.recommendedOptionId &&
-      !decision.options.some((option) => option.optionId === decision.recommendedOptionId)
-    ) {
-      context.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["recommendedOptionId"],
-        message: "Recommended option must resolve inside the decision",
-      });
-    }
-  });
-
-export const decisionResolutionV1Schema = z
-  .object({ decisionId: shortString(), selectedOptionId: shortString() })
-  .strict();
-
-export const featurePinsV1Schema = z
-  .object({
-    bindingId: shortString(),
-    grounding: z
-      .object({
-        sourceCommitId: shortString(),
-        analysisPlanDigest: digestHexStringSchema,
-        contextSliceDigest: digestHexStringSchema,
-      })
-      .strict(),
-    authority: z
-      .object({
-        fcid: digestHexStringSchema,
-        contractArtifactDigest: digestHexStringSchema,
-        analysisObligationsDigest: digestHexStringSchema,
-      })
-      .strict(),
-    evidenceDigest: digestHexStringSchema,
-  })
-  .strict();
-
-const commonRevisionShape = {
-  pins: featurePinsV1Schema,
-  placement: placementDecisionV1Schema,
-  componentUses: z.array(componentUseDecisionV1Schema).max(FEATURE_PLAN_MAX_USES_PER_KIND_V1),
-  tokenUses: z.array(tokenUseDecisionV1Schema).max(FEATURE_PLAN_MAX_USES_PER_KIND_V1),
-  patternUses: z.array(patternUseDecisionV1Schema).max(FEATURE_PLAN_MAX_USES_PER_KIND_V1),
-  layout: layoutOwnershipV1Schema,
-  responsive: z.array(responsiveDecisionV1Schema).max(FEATURE_PLAN_MAX_DECISIONS_V1),
-  scenarios: z.array(scenarioRequirementV1Schema).max(FEATURE_PLAN_MAX_SCENARIOS_V1),
-  gaps: z.array(capabilityGapV1Schema).max(FEATURE_PLAN_MAX_GAPS_V1),
-  acceptance: z.array(featureAcceptanceItemV1Schema).max(FEATURE_PLAN_MAX_ACCEPTANCE_ITEMS_V1),
-  evidenceRefs: z.array(evidenceRefV1Schema).max(FEATURE_PLAN_MAX_EVIDENCE_REFS_V1),
-};
-
-function addUniqueIdIssue(
-  rows: readonly Record<string, unknown>[],
-  key: string,
-  path: string,
-  context: z.RefinementCtx
-): void {
-  const values = rows
-    .map((row) => row[key])
-    .filter((value): value is string => typeof value === "string");
-  if (new Set(values).size !== values.length) {
-    context.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: [path],
-      message: `${path} IDs must be unique`,
-    });
-  }
-}
-
-type CommonGraph = z.infer<z.ZodObject<typeof commonRevisionShape>>;
-
-function validateCommonGraph(
-  graph: CommonGraph,
-  context: z.RefinementCtx,
-  decisionIds: ReadonlySet<string>
-): void {
-  addUniqueIdIssue(graph.evidenceRefs, "evidenceId", "evidenceRefs", context);
-  addUniqueIdIssue(graph.componentUses, "useId", "componentUses", context);
-  addUniqueIdIssue(graph.tokenUses, "useId", "tokenUses", context);
-  addUniqueIdIssue(graph.patternUses, "useId", "patternUses", context);
-  addUniqueIdIssue(graph.responsive, "decisionId", "responsive", context);
-  addUniqueIdIssue(graph.scenarios, "scenarioId", "scenarios", context);
-  addUniqueIdIssue(graph.gaps, "gapId", "gaps", context);
-  addUniqueIdIssue(graph.acceptance, "acceptanceId", "acceptance", context);
-
-  const evidenceIds = new Set(graph.evidenceRefs.map((evidence) => evidence.evidenceId));
-  const acceptanceIds = new Set(graph.acceptance.map((acceptance) => acceptance.acceptanceId));
-  const evidenceReferences: Array<readonly [readonly string[], string]> = [
-    [graph.placement.evidenceRefIds, "placement.evidenceRefIds"],
-    ...graph.componentUses.map(
-      (row, index) => [row.evidenceRefIds, `componentUses.${index}.evidenceRefIds`] as const
-    ),
-    ...graph.tokenUses.map(
-      (row, index) => [row.evidenceRefIds, `tokenUses.${index}.evidenceRefIds`] as const
-    ),
-    ...graph.patternUses.map(
-      (row, index) => [row.evidenceRefIds, `patternUses.${index}.evidenceRefIds`] as const
-    ),
-    ...graph.layout.concerns.map(
-      (row, index) => [row.evidenceRefIds, `layout.concerns.${index}.evidenceRefIds`] as const
-    ),
-    ...graph.responsive.map(
-      (row, index) => [row.evidenceRefIds, `responsive.${index}.evidenceRefIds`] as const
-    ),
-    ...graph.gaps.map(
-      (row, index) => [row.evidenceRefIds, `gaps.${index}.evidenceRefIds`] as const
-    ),
-    ...graph.acceptance.map(
-      (row, index) => [row.evidenceRefIds, `acceptance.${index}.evidenceRefIds`] as const
-    ),
-  ];
-  for (const [references, path] of evidenceReferences) {
-    for (const reference of references) {
-      if (!evidenceIds.has(reference)) {
-        context.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: path.split("."),
-          message: `Unknown evidence reference: ${reference}`,
-        });
-      }
-    }
-  }
-  for (const [index, scenario] of graph.scenarios.entries()) {
-    for (const acceptanceId of scenario.acceptanceIds) {
-      if (!acceptanceIds.has(acceptanceId)) {
-        context.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ["scenarios", index, "acceptanceIds"],
-          message: `Unknown acceptance reference: ${acceptanceId}`,
-        });
-      }
-    }
-  }
-  for (const [index, row] of graph.layout.concerns.entries()) {
-    if (row.overrideDecisionId && !decisionIds.has(row.overrideDecisionId)) {
-      context.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["layout", "concerns", index, "overrideDecisionId"],
-        message: `Unknown decision reference: ${row.overrideDecisionId}`,
-      });
-    }
-  }
-}
-
-const proposalInputShape = {
-  schemaVersion: z.literal(1),
-  kind: z.literal("proposal"),
-  planId: featurePlanIdStringSchema,
-  parentRevisionDigest: digestHexStringSchema.optional(),
-  ...commonRevisionShape,
-  questions: z.array(decisionRequestV1Schema).max(FEATURE_PLAN_MAX_DECISIONS_V1),
-};
-
-function validateProposal(
-  proposal: z.infer<z.ZodObject<typeof proposalInputShape>>,
-  context: z.RefinementCtx
-): void {
-  addUniqueIdIssue(proposal.questions, "decisionId", "questions", context);
-  const decisionIds = new Set(proposal.questions.map((question) => question.decisionId));
-  validateCommonGraph(proposal, context, decisionIds);
-  const evidenceIds = new Set(proposal.evidenceRefs.map((evidence) => evidence.evidenceId));
-  for (const [index, question] of proposal.questions.entries()) {
-    for (const reference of question.evidenceRefIds) {
-      if (!evidenceIds.has(reference)) {
-        context.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ["questions", index, "evidenceRefIds"],
-          message: `Unknown evidence reference: ${reference}`,
-        });
-      }
-    }
-  }
-}
-
-export const featureProposalInputV1Schema = z
-  .object(proposalInputShape)
-  .strict()
-  .superRefine(validateProposal);
-
-export const featureProposalV1Schema = z
-  .object({
-    ...proposalInputShape,
-    revisionId: featureRevisionIdStringSchema,
-    revisionDigest: digestHexStringSchema,
-  })
-  .strict()
-  .superRefine(validateProposal);
-
-const manifestInputShape = {
-  schemaVersion: z.literal(1),
-  kind: z.literal("approved_manifest"),
-  planId: featurePlanIdStringSchema,
-  parentRevisionDigest: digestHexStringSchema,
-  proposalRevisionDigest: digestHexStringSchema,
-  ...commonRevisionShape,
-  validatedGrounding: z
-    .object({
-      sourceCommitId: shortString(),
-      analysisPlanDigest: digestHexStringSchema,
-      contextSliceDigest: digestHexStringSchema,
-    })
-    .strict(),
-  decisions: z.array(decisionResolutionV1Schema).max(FEATURE_PLAN_MAX_DECISIONS_V1),
-  approval: z
-    .object({
-      approverUserId: shortString(),
-      decisionDigest: digestHexStringSchema,
-      approvedAt: z.string().datetime({ offset: true }),
-      expiresAt: z.string().datetime({ offset: true }).optional(),
-    })
-    .strict(),
-};
-
-const portableRepositoryPathSchema = shortString().refine(
-  (value) => !value.startsWith("/") && !value.includes("\\") && !value.split("/").includes(".."),
-  "Expected a portable repository-relative path"
-);
-
-function validateManifest(
-  manifest: z.infer<z.ZodObject<typeof manifestInputShape>>,
-  context: z.RefinementCtx
-): void {
-  addUniqueIdIssue(manifest.decisions, "decisionId", "decisions", context);
-  validateCommonGraph(manifest, context, new Set(manifest.decisions.map((row) => row.decisionId)));
-  if (
-    manifest.validatedGrounding.contextSliceDigest !== manifest.pins.grounding.contextSliceDigest
-  ) {
-    context.addIssue({
-      code: z.ZodIssueCode.custom,
-      path: ["validatedGrounding", "contextSliceDigest"],
-      message: "Validated material context must match the pinned proposal context",
-    });
-  }
-  for (const [index, gap] of manifest.gaps.entries()) {
-    if (
-      gap.required &&
-      (gap.disposition === "unresolved" || gap.disposition === "proposed_contract_addition")
-    ) {
-      context.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["gaps", index, "disposition"],
-        message:
-          "A required unresolved or proposed-contract gap blocks approval until it is resolved",
-      });
-    }
-  }
-}
-
-export const approvedFeatureManifestInputV1Schema = z
-  .object(manifestInputShape)
-  .strict()
-  .superRefine(validateManifest);
-
-export const approvedFeatureManifestV1Schema = z
-  .object({
-    ...manifestInputShape,
-    revisionId: featureRevisionIdStringSchema,
-    revisionDigest: digestHexStringSchema,
-  })
-  .strict()
-  .superRefine(validateManifest);
-
-export const agentFeatureContextV1Schema = z
-  .object({
-    schemaVersion: z.literal(1),
-    planId: featurePlanIdStringSchema,
-    manifestDigest: digestHexStringSchema,
-    pins: featurePinsV1Schema,
-    validatedGrounding: manifestInputShape.validatedGrounding,
-    target: placementDecisionV1Schema,
-    componentUses: commonRevisionShape.componentUses,
-    tokenUses: commonRevisionShape.tokenUses,
-    patternUses: commonRevisionShape.patternUses,
-    layout: layoutOwnershipV1Schema,
-    responsive: commonRevisionShape.responsive,
-    scenarios: commonRevisionShape.scenarios,
-    acceptedGaps: commonRevisionShape.gaps,
-    acceptance: commonRevisionShape.acceptance,
-    decisions: manifestInputShape.decisions,
-    relevantFiles: z
-      .array(portableRepositoryPathSchema)
-      .max(500)
-      .refine(unique, "relevantFiles must be unique"),
-    commands: z.array(boundedString()).max(100),
-  })
-  .strict()
-  .superRefine((contextValue, context) => {
-    const graph = {
-      pins: contextValue.pins,
-      placement: contextValue.target,
-      componentUses: contextValue.componentUses,
-      tokenUses: contextValue.tokenUses,
-      patternUses: contextValue.patternUses,
-      layout: contextValue.layout,
-      responsive: contextValue.responsive,
-      scenarios: contextValue.scenarios,
-      gaps: contextValue.acceptedGaps,
-      acceptance: contextValue.acceptance,
-      evidenceRefs: [],
-    };
-    // Evidence bodies are deliberately absent from the bounded agent projection,
-    // so validate decision/acceptance/layout identity here and evidence links at
-    // manifest construction time.
-    addUniqueIdIssue(contextValue.decisions, "decisionId", "decisions", context);
-    addUniqueIdIssue(graph.componentUses, "useId", "componentUses", context);
-    addUniqueIdIssue(graph.tokenUses, "useId", "tokenUses", context);
-    addUniqueIdIssue(graph.patternUses, "useId", "patternUses", context);
-    addUniqueIdIssue(graph.scenarios, "scenarioId", "scenarios", context);
-    addUniqueIdIssue(graph.acceptance, "acceptanceId", "acceptance", context);
-    const decisions = new Set(contextValue.decisions.map((row) => row.decisionId));
-    for (const [index, row] of contextValue.layout.concerns.entries()) {
-      if (row.overrideDecisionId && !decisions.has(row.overrideDecisionId)) {
-        context.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ["layout", "concerns", index, "overrideDecisionId"],
-          message: `Unknown decision reference: ${row.overrideDecisionId}`,
-        });
-      }
-    }
-    for (const [index, gap] of contextValue.acceptedGaps.entries()) {
-      if (
-        gap.required &&
-        (gap.disposition === "unresolved" || gap.disposition === "proposed_contract_addition")
-      ) {
-        context.addIssue({
-          code: z.ZodIssueCode.custom,
-          path: ["acceptedGaps", index],
-          message: "Agent context cannot contain a required unresolved or proposed-contract gap",
-        });
-      }
-    }
-  });
-
-export type EvidenceRefV1 = z.infer<typeof evidenceRefV1Schema>;
-export type PlacementDecisionV1 = z.infer<typeof placementDecisionV1Schema>;
-export type ComponentUseDecisionV1 = z.infer<typeof componentUseDecisionV1Schema>;
-export type TokenUseDecisionV1 = z.infer<typeof tokenUseDecisionV1Schema>;
-export type PatternStatusV1 = z.infer<typeof patternStatusV1Schema>;
-export type PatternUseDecisionV1 = z.infer<typeof patternUseDecisionV1Schema>;
-export type LayoutConcernV1 = z.infer<typeof layoutConcernV1Schema>;
-export type LayoutOwnershipV1 = z.infer<typeof layoutOwnershipV1Schema>;
-export type ResponsiveDecisionV1 = z.infer<typeof responsiveDecisionV1Schema>;
-export type ScenarioRequirementV1 = z.infer<typeof scenarioRequirementV1Schema>;
-export type GapDispositionV1 = z.infer<typeof gapDispositionV1Schema>;
-export type CapabilityGapV1 = z.infer<typeof capabilityGapV1Schema>;
-export type FeatureAcceptanceItemV1 = z.infer<typeof featureAcceptanceItemV1Schema>;
-export type DecisionRequestV1 = z.infer<typeof decisionRequestV1Schema>;
-export type DecisionResolutionV1 = z.infer<typeof decisionResolutionV1Schema>;
-export type FeaturePinsV1 = z.infer<typeof featurePinsV1Schema>;
-export type FeatureProposalInputV1 = z.input<typeof featureProposalInputV1Schema> & {
-  planId: FeaturePlanId;
-};
-export type FeatureProposalV1 = z.output<typeof featureProposalV1Schema> & {
-  planId: FeaturePlanId;
-  revisionId: FeatureRevisionId;
-};
-export type ApprovedFeatureManifestInputV1 = z.input<
-  typeof approvedFeatureManifestInputV1Schema
-> & { planId: FeaturePlanId };
-export type ApprovedFeatureManifestV1 = z.output<typeof approvedFeatureManifestV1Schema> & {
-  planId: FeaturePlanId;
-  revisionId: FeatureRevisionId;
-};
-export type AgentFeatureContextV1 = z.output<typeof agentFeatureContextV1Schema> & {
-  planId: FeaturePlanId;
-};