@topogram/cli 0.3.34

package/src/generator/components.js

@@ -0,0 +1,39 @@
+function stableSortedComponents(graph) {
+  return [...(graph?.byKind?.component || [])].sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function componentContract(component) {
+  return component.componentContract || {
+    type: "component_contract",
+    id: component.id,
+    name: component.name || component.id,
+    description: component.description || null,
+    category: component.category || null,
+    version: component.version || null,
+    status: component.status || null,
+    props: component.props || [],
+    events: component.events || [],
+    slots: component.slots || [],
+    behavior: component.behavior || [],
+    behaviors: component.behaviors || [],
+    patterns: component.patterns || [],
+    regions: component.regions || [],
+    approvals: component.approvals || [],
+    lookups: component.lookups || [],
+    dependencies: component.dependencies || []
+  };
+}
+
+export function generateUiComponentContract(graph, options = {}) {
+  if (options.componentId) {
+    const component = (graph?.byKind?.component || []).find((entry) => entry.id === options.componentId);
+    if (!component) {
+      throw new Error(`No component found with id '${options.componentId}'`);
+    }
+    return componentContract(component);
+  }
+
+  return Object.fromEntries(
+    stableSortedComponents(graph).map((component) => [component.id, componentContract(component)])
+  );
+}

package/src/generator/context/bundle.js

@@ -0,0 +1,291 @@
+import {
+  buildMaintainedOutputs,
+  buildMaintainedBoundaryArtifact,
+  buildMaintainedSeams,
+  buildDefaultWriteScope,
+  buildMaintainedWriteScope,
+  maintainedProofMetadata,
+  relatedCapabilitiesForEntity,
+  relatedCapabilitiesForProjection,
+  relatedEntitiesForProjection,
+  recommendedVerificationTargets,
+  stableSortedStrings,
+  summarizeById,
+  summarizeDocsByIds,
+  summarizeStatementsByIds,
+  verificationIdsForTarget
+} from "./shared.js";
+import {
+  defaultOwnershipBoundary,
+  ownershipBoundaryForMaintainedSurface,
+  reviewBoundaryForJourneyDoc,
+  reviewBoundaryForWorkflowDoc
+} from "../../policy/review-boundaries.js";
+
+function apiBundle(graph) {
+  const capabilities = stableSortedStrings((graph.byKind.capability || []).map((item) => item.id));
+  const projections = stableSortedStrings(
+    (graph.byKind.projection || [])
+      .filter((projection) => (projection.http || []).length > 0)
+      .map((projection) => projection.id)
+  );
+  const shapes = stableSortedStrings(capabilities.flatMap((capabilityId) => {
+    const capability = (graph.byKind.capability || []).find((item) => item.id === capabilityId);
+    return [...(capability?.input || []).map((item) => item.id), ...(capability?.output || []).map((item) => item.id)];
+  }));
+  const rules = stableSortedStrings(capabilities.flatMap((capabilityId) => {
+    return (graph.byKind.rule || [])
+      .filter((rule) => (rule.appliesTo || []).some((target) => target.id === capabilityId))
+      .map((rule) => rule.id);
+  }));
+
+  return {
+    type: "context_bundle",
+    version: 1,
+    task: "api",
+    summary: {
+      focus: "API-facing capability, shape, and projection context",
+      capabilityCount: capabilities.length,
+      projectionCount: projections.length
+    },
+    included_surfaces: {
+      capabilities: summarizeStatementsByIds(graph, capabilities),
+      shapes: summarizeStatementsByIds(graph, shapes),
+      projections: summarizeStatementsByIds(graph, projections),
+      rules: summarizeStatementsByIds(graph, rules)
+    },
+    dependencies: {
+      capabilities,
+      shapes,
+      projections,
+      rules
+    },
+    verification: summarizeStatementsByIds(graph, verificationIdsForTarget(graph, [...capabilities, ...projections])),
+    verification_targets: recommendedVerificationTargets(graph, [...capabilities, ...projections], {
+      rationale: "API bundle should point agents at API-facing generated checks instead of full workspace verification."
+    }),
+    write_scope: buildDefaultWriteScope(),
+    ownership_boundary: defaultOwnershipBoundary(),
+    review_boundaries: {
+      capabilities: capabilities.map((id) => ({ id, review_boundary: summarizeById(graph, id)?.reviewBoundary || null })),
+      projections: projections.map((id) => ({ id, review_boundary: summarizeById(graph, id)?.reviewBoundary || null }))
+    }
+  };
+}
+
+function uiBundle(graph) {
+  const projections = stableSortedStrings(
+    (graph.byKind.projection || [])
+      .filter((projection) => (projection.uiScreens || []).length > 0 || (projection.uiWeb || []).length > 0)
+      .map((projection) => projection.id)
+  );
+  const capabilities = stableSortedStrings(projections.flatMap((projectionId) => {
+    const projection = (graph.byKind.projection || []).find((item) => item.id === projectionId);
+    return relatedCapabilitiesForProjection(projection);
+  }));
+  const workflows = stableSortedStrings(
+    (graph.docs || [])
+      .filter((doc) => doc.kind === "workflow" && (doc.relatedProjections || []).some((id) => projections.includes(id)))
+      .map((doc) => doc.id)
+  );
+  const journeys = stableSortedStrings(
+    (graph.docs || [])
+      .filter((doc) => doc.kind === "journey" && (doc.relatedProjections || []).some((id) => projections.includes(id)))
+      .map((doc) => doc.id)
+  );
+  const rules = stableSortedStrings(capabilities.flatMap((capabilityId) => {
+    return (graph.byKind.rule || [])
+      .filter((rule) => (rule.appliesTo || []).some((target) => target.id === capabilityId))
+      .map((rule) => rule.id);
+  }));
+
+  return {
+    type: "context_bundle",
+    version: 1,
+    task: "ui",
+    summary: {
+      focus: "UI workflows, journeys, projections, and action semantics",
+      projectionCount: projections.length,
+      workflowCount: workflows.length
+    },
+    included_surfaces: {
+      projections: summarizeStatementsByIds(graph, projections),
+      capabilities: summarizeStatementsByIds(graph, capabilities),
+      workflows: summarizeDocsByIds(graph, workflows),
+      journeys: summarizeDocsByIds(graph, journeys),
+      rules: summarizeStatementsByIds(graph, rules)
+    },
+    dependencies: {
+      projections,
+      capabilities,
+      workflows,
+      journeys,
+      rules
+    },
+    verification: summarizeStatementsByIds(graph, verificationIdsForTarget(graph, [...capabilities, ...projections, ...workflows, ...journeys])),
+    verification_targets: recommendedVerificationTargets(graph, [...capabilities, ...projections, ...workflows, ...journeys], {
+      rationale: "UI bundle should target workflow and UI verification linked to the selected projections."
+    }),
+    write_scope: buildDefaultWriteScope(),
+    ownership_boundary: defaultOwnershipBoundary(),
+    review_boundaries: {
+      projections: projections.map((id) => ({ id, review_boundary: summarizeById(graph, id)?.reviewBoundary || null })),
+      workflows: workflows.map((id) => ({ id, review_boundary: reviewBoundaryForWorkflowDoc((graph.docs || []).find((doc) => doc.id === id)) })),
+      journeys: journeys.map((id) => ({ id, review_boundary: reviewBoundaryForJourneyDoc((graph.docs || []).find((doc) => doc.id === id)) }))
+    }
+  };
+}
+
+function dbBundle(graph) {
+  const projections = stableSortedStrings(
+    (graph.byKind.projection || [])
+      .filter((projection) => (projection.dbTables || []).length > 0 || (projection.dbColumns || []).length > 0)
+      .map((projection) => projection.id)
+  );
+  const entities = stableSortedStrings(projections.flatMap((projectionId) => {
+    const projection = (graph.byKind.projection || []).find((item) => item.id === projectionId);
+    return relatedEntitiesForProjection(projection);
+  }));
+  const capabilities = stableSortedStrings(entities.flatMap((entityId) => relatedCapabilitiesForEntity(graph, entityId)));
+  const enums = stableSortedStrings((graph.byKind.enum || []).map((item) => item.id));
+
+  return {
+    type: "context_bundle",
+    version: 1,
+    task: "db",
+    summary: {
+      focus: "DB schema, relations, and migration-sensitive semantics",
+      projectionCount: projections.length,
+      entityCount: entities.length
+    },
+    included_surfaces: {
+      projections: summarizeStatementsByIds(graph, projections),
+      entities: summarizeStatementsByIds(graph, entities),
+      enums: summarizeStatementsByIds(graph, enums),
+      capabilities: summarizeStatementsByIds(graph, capabilities)
+    },
+    dependencies: {
+      projections,
+      entities,
+      enums,
+      capabilities
+    },
+    verification: summarizeStatementsByIds(graph, verificationIdsForTarget(graph, [...projections, ...entities])),
+    verification_targets: recommendedVerificationTargets(graph, [...projections, ...entities], {
+      rationale: "DB bundle should target schema and runtime checks tied to affected entities and projections."
+    }),
+    write_scope: buildDefaultWriteScope(),
+    ownership_boundary: defaultOwnershipBoundary(),
+    review_boundaries: {
+      projections: projections.map((id) => ({ id, review_boundary: summarizeById(graph, id)?.reviewBoundary || null })),
+      entities: entities.map((id) => ({ id, review_boundary: { automation_class: "review_required", reasons: ["schema_surface"] } }))
+    }
+  };
+}
+
+function maintainedAppBundle(graph) {
+  const proofStories = maintainedProofMetadata(graph);
+  const projections = stableSortedStrings((graph.byKind.projection || []).map((item) => item.id));
+  const journeys = stableSortedStrings((graph.docs || []).filter((doc) => doc.kind === "journey").map((doc) => doc.id));
+  const verifications = stableSortedStrings((graph.byKind.verification || []).map((item) => item.id));
+  const maintainedFiles = stableSortedStrings(proofStories.flatMap((item) => item.maintainedFiles || []));
+  const emittedDependencies = stableSortedStrings(proofStories.flatMap((item) => item.emittedDependencies || []));
+  const humanOwnedSeams = stableSortedStrings(proofStories.flatMap((item) => item.humanOwnedSeams || []));
+  const verificationTargets = recommendedVerificationTargets(graph, [...verifications, ...emittedDependencies], {
+    includeMaintainedApp: true,
+    rationale: "Maintained-app bundle should point agents at both generated verification and maintained proof gates."
+  });
+  const maintainedBoundaryArtifact = buildMaintainedBoundaryArtifact({
+    proofStories,
+    verificationTargets,
+    graph
+  });
+  const outputs = maintainedBoundaryArtifact?.outputs || [];
+  const seams = maintainedBoundaryArtifact?.seams || [];
+
+  return {
+    type: "context_bundle",
+    version: 1,
+    task: "maintained-app",
+    summary: {
+      focus: "Maintained-app proof boundaries and human-owned change surfaces",
+      accepted_change_count: proofStories.filter((item) => item.classification === "accepted_change").length,
+      guarded_change_count: proofStories.filter((item) => item.classification === "guarded_manual_decision").length,
+      no_go_count: proofStories.filter((item) => item.classification === "no_go").length
+    },
+    included_surfaces: {
+      projections: summarizeStatementsByIds(graph, projections),
+      journeys: summarizeDocsByIds(graph, journeys),
+      maintained_files_in_scope: maintainedFiles,
+      emitted_artifact_dependencies: emittedDependencies,
+      human_owned_seams: humanOwnedSeams,
+      outputs,
+      seams,
+      proof_stories: proofStories.map((item) => ({
+        classification: item.classification,
+        relativePath: item.relativePath,
+        maintained_files: item.maintainedFiles || [],
+        emitted_dependencies: item.emittedDependencies || [],
+        human_owned_seams: item.humanOwnedSeams || [],
+        review_boundary: item.reviewBoundary
+      }))
+    },
+    dependencies: {
+      projections,
+      journeys,
+      verifications,
+      maintained_files: maintainedFiles,
+      emitted_dependencies: emittedDependencies
+    },
+    verification: summarizeStatementsByIds(graph, verifications),
+    verification_targets: verificationTargets,
+    write_scope: buildMaintainedWriteScope(graph, maintainedFiles),
+    ownership_boundary: ownershipBoundaryForMaintainedSurface(),
+    maintained_boundary: maintainedBoundaryArtifact,
+    review_boundaries: {
+      maintained_surfaces: [
+        {
+          class: "accepted_change",
+          description: "Maintained surface should mirror emitted Topogram artifacts directly.",
+          review_boundary: proofStories.find((item) => item.classification === "accepted_change")?.reviewBoundary || null
+        },
+        {
+          class: "guarded_manual_decision",
+          description: "Topogram identifies the affected surface, but product or UX treatment remains human-owned.",
+          review_boundary: proofStories.find((item) => item.classification === "guarded_manual_decision")?.reviewBoundary || null
+        },
+        {
+          class: "no_go",
+          description: "Unsafe semantic drift or relation changes should not be auto-applied.",
+          review_boundary: proofStories.find((item) => item.classification === "no_go")?.reviewBoundary || null
+        }
+      ],
+      human_owned_seams: humanOwnedSeams,
+      independent_review_artifacts: proofStories
+        .filter((item) => item.classification === "independent_review")
+        .map((item) => item.relativePath)
+    }
+  };
+}
+
+export function generateContextBundle(graph, options = {}) {
+  const task = options.taskId;
+  if (!task) {
+    throw new Error("context-bundle requires --task <api|ui|db|maintained-app>");
+  }
+
+  if (task === "api") {
+    return apiBundle(graph);
+  }
+  if (task === "ui") {
+    return uiBundle(graph);
+  }
+  if (task === "db") {
+    return dbBundle(graph);
+  }
+  if (task === "maintained-app") {
+    return maintainedAppBundle(graph);
+  }
+
+  throw new Error(`Unsupported context bundle task '${task}'`);
+}

package/src/generator/context/diff.js

@@ -0,0 +1,256 @@
+import { parsePath } from "../../parser.js";
+import { resolveWorkspace } from "../../resolver.js";
+import {
+  buildMaintainedOutputs,
+  buildMaintainedSeams,
+  maintainedProofMetadata,
+  relatedCapabilitiesForEntity,
+  relatedProjectionsForCapability,
+  relatedProjectionsForComponent,
+  relatedProjectionsForEntity,
+  stableSortedStrings,
+  summarizeById,
+  summarizeDoc,
+  summarizeStatement
+} from "./shared.js";
+import { defaultOwnershipBoundary } from "../../policy/review-boundaries.js";
+
+function normalizeTargetMap(graph, kind) {
+  if (kind === "workflow" || kind === "journey") {
+    const docs = (graph.docs || []).filter((doc) => doc.kind === kind);
+    return new Map(docs.map((doc) => [doc.id, summarizeDoc(doc)]));
+  }
+
+  return new Map(((graph.byKind[kind] || []).map((statement) => [statement.id, summarizeStatement(statement)])));
+}
+
+function diffMaps(currentMap, baselineMap) {
+  const ids = stableSortedStrings([...currentMap.keys(), ...baselineMap.keys()]);
+  const output = [];
+
+  for (const id of ids) {
+    const current = currentMap.get(id);
+    const baseline = baselineMap.get(id);
+    if (!baseline && current) {
+      output.push({
+        id,
+        classification: "additive",
+        current
+      });
+      continue;
+    }
+    if (baseline && !current) {
+      output.push({
+        id,
+        classification: "removed",
+        baseline
+      });
+      continue;
+    }
+
+    const currentJson = JSON.stringify(current);
+    const baselineJson = JSON.stringify(baseline);
+    if (currentJson === baselineJson) {
+      continue;
+    }
+
+    const currentBoundary = current?.reviewBoundary || current?.review_boundary || null;
+    const baselineBoundary = baseline?.reviewBoundary || baseline?.review_boundary || null;
+    const classification =
+      JSON.stringify(currentBoundary) !== JSON.stringify(baselineBoundary) ? "review_boundary_changed" : "modified";
+
+    output.push({
+      id,
+      classification,
+      current,
+      baseline
+    });
+  }
+
+  return output;
+}
+
+function changedIdsForDiffSections(diff) {
+  const sectionNames = [
+    "entities",
+    "enums",
+    "shapes",
+    "capabilities",
+    "rules",
+    "workflows",
+    "projections",
+    "components",
+    "journeys",
+    "verifications",
+    "domains",
+    "pitches",
+    "requirements",
+    "acceptance_criteria",
+    "tasks",
+    "bugs"
+  ];
+  const ids = [];
+  for (const section of sectionNames) {
+    ids.push(...(diff[section] || []).map((entry) => entry.id));
+  }
+  return stableSortedStrings(ids);
+}
+
+function collectAffectedProjectionIds(graph, baselineGraph, diff) {
+  const changedCapabilities = stableSortedStrings((diff.capabilities || []).map((entry) => entry.id));
+  const changedEntities = stableSortedStrings((diff.entities || []).map((entry) => entry.id));
+  const changedProjections = stableSortedStrings((diff.projections || []).map((entry) => entry.id));
+  const changedComponentProjections = stableSortedStrings((diff.components || []).flatMap((entry) => {
+    if (entry.classification === "additive") {
+      return relatedProjectionsForComponent(graph, entry.id);
+    }
+    if (entry.classification === "removed") {
+      return relatedProjectionsForComponent(baselineGraph, entry.id);
+    }
+    return [
+      ...relatedProjectionsForComponent(graph, entry.id),
+      ...relatedProjectionsForComponent(baselineGraph, entry.id)
+    ];
+  }));
+
+  return stableSortedStrings([
+    ...changedProjections,
+    ...changedCapabilities.flatMap((id) => relatedProjectionsForCapability(graph, id)),
+    ...changedEntities.flatMap((id) => relatedProjectionsForEntity(graph, id)),
+    ...changedComponentProjections
+  ]);
+}
+
+function collectAffectedCapabilityIds(graph, diff) {
+  const changedCapabilities = stableSortedStrings((diff.capabilities || []).map((entry) => entry.id));
+  const changedEntities = stableSortedStrings((diff.entities || []).map((entry) => entry.id));
+  return stableSortedStrings([
+    ...changedCapabilities,
+    ...changedEntities.flatMap((id) => relatedCapabilitiesForEntity(graph, id))
+  ]);
+}
+
+function collectAffectedVerificationIds(graph, diff) {
+  const changedIds = changedIdsForDiffSections(diff);
+  const explicitVerificationIds = stableSortedStrings((diff.verifications || []).map((entry) => entry.id));
+  const affected = (graph.byKind.verification || [])
+    .filter((verification) => (verification.validates || []).some((target) => changedIds.includes(target.id)))
+    .map((verification) => verification.id);
+  return stableSortedStrings([...explicitVerificationIds, ...affected]);
+}
+
+function reviewBoundaryChanges(diff) {
+  const sectionNames = [
+    "entities",
+    "capabilities",
+    "workflows",
+    "projections",
+    "journeys"
+  ];
+  return sectionNames.flatMap((section) =>
+    (diff[section] || [])
+      .filter((entry) => entry.classification === "review_boundary_changed")
+      .map((entry) => ({
+        kind: section.slice(0, -1),
+        id: entry.id,
+        baseline: entry.baseline?.reviewBoundary || entry.baseline?.review_boundary || null,
+        current: entry.current?.reviewBoundary || entry.current?.review_boundary || null
+      }))
+  );
+}
+
+function loadBaselineGraph(fromTopogramPath) {
+  if (!fromTopogramPath) {
+    throw new Error("context-diff requires --from-topogram <path>");
+  }
+
+  const parsed = parsePath(fromTopogramPath);
+  const resolved = resolveWorkspace(parsed);
+  if (!resolved.ok) {
+    throw Object.assign(new Error("Failed to resolve baseline Topogram"), { validation: resolved.validation });
+  }
+
+  return resolved.graph;
+}
+
+export function generateContextDiff(graph, options = {}) {
+  const baselineGraph = loadBaselineGraph(options.fromTopogramPath);
+  const diff = {
+    entities: diffMaps(normalizeTargetMap(graph, "entity"), normalizeTargetMap(baselineGraph, "entity")),
+    enums: diffMaps(normalizeTargetMap(graph, "enum"), normalizeTargetMap(baselineGraph, "enum")),
+    shapes: diffMaps(normalizeTargetMap(graph, "shape"), normalizeTargetMap(baselineGraph, "shape")),
+    capabilities: diffMaps(normalizeTargetMap(graph, "capability"), normalizeTargetMap(baselineGraph, "capability")),
+    rules: diffMaps(normalizeTargetMap(graph, "rule"), normalizeTargetMap(baselineGraph, "rule")),
+    workflows: diffMaps(normalizeTargetMap(graph, "workflow"), normalizeTargetMap(baselineGraph, "workflow")),
+    projections: diffMaps(normalizeTargetMap(graph, "projection"), normalizeTargetMap(baselineGraph, "projection")),
+    components: diffMaps(normalizeTargetMap(graph, "component"), normalizeTargetMap(baselineGraph, "component")),
+    journeys: diffMaps(normalizeTargetMap(graph, "journey"), normalizeTargetMap(baselineGraph, "journey")),
+    verifications: diffMaps(normalizeTargetMap(graph, "verification"), normalizeTargetMap(baselineGraph, "verification")),
+    domains: diffMaps(normalizeTargetMap(graph, "domain"), normalizeTargetMap(baselineGraph, "domain")),
+    pitches: diffMaps(normalizeTargetMap(graph, "pitch"), normalizeTargetMap(baselineGraph, "pitch")),
+    requirements: diffMaps(normalizeTargetMap(graph, "requirement"), normalizeTargetMap(baselineGraph, "requirement")),
+    acceptance_criteria: diffMaps(
+      normalizeTargetMap(graph, "acceptance_criterion"),
+      normalizeTargetMap(baselineGraph, "acceptance_criterion")
+    ),
+    tasks: diffMaps(normalizeTargetMap(graph, "task"), normalizeTargetMap(baselineGraph, "task")),
+    bugs: diffMaps(normalizeTargetMap(graph, "bug"), normalizeTargetMap(baselineGraph, "bug"))
+  };
+  const sdlcChanges = {
+    pitches: diff.pitches || [],
+    requirements: diff.requirements || [],
+    acceptance_criteria: diff.acceptance_criteria || [],
+    tasks: diff.tasks || [],
+    bugs: diff.bugs || []
+  };
+  const affectedCapabilities = collectAffectedCapabilityIds(graph, diff);
+  const affectedProjections = collectAffectedProjectionIds(graph, baselineGraph, diff);
+  const affectedVerifications = collectAffectedVerificationIds(graph, diff);
+  const changedSemanticIds = changedIdsForDiffSections(diff);
+  const affectedMaintainedStories = maintainedProofMetadata(graph).filter((item) => {
+    const emittedDependencies = item.emittedDependencies || [];
+    return emittedDependencies.includes("maintained-proof-package") || emittedDependencies.some((dependency) => changedSemanticIds.includes(dependency));
+  });
+  const affectedMaintainedSeams = buildMaintainedSeams(affectedMaintainedStories);
+  const affectedMaintainedOutputs = buildMaintainedOutputs({
+    seams: affectedMaintainedSeams,
+    proofStories: affectedMaintainedStories,
+    ownershipBoundary: defaultOwnershipBoundary(),
+    graph
+  });
+  const reviewBoundaryChangeItems = reviewBoundaryChanges(diff);
+
+  return {
+    type: "context_diff",
+    version: 1,
+    current_root: graph.root,
+    baseline_root: baselineGraph.root,
+    ownership_boundary: defaultOwnershipBoundary(),
+    ...diff,
+    affected_generated_surfaces: {
+      capabilities: affectedCapabilities.map((id) => summarizeById(graph, id)).filter(Boolean),
+      projections: affectedProjections.map((id) => summarizeById(graph, id) || summarizeById(baselineGraph, id)).filter(Boolean),
+      workflows: stableSortedStrings((diff.workflows || []).map((entry) => entry.id)).map((id) => summarizeById(graph, id) || summarizeById(baselineGraph, id)).filter(Boolean),
+      journeys: stableSortedStrings((diff.journeys || []).map((entry) => entry.id)).map((id) => summarizeById(graph, id) || summarizeById(baselineGraph, id)).filter(Boolean)
+    },
+    affected_maintained_surfaces: {
+      ownership_interpretation: {
+        generated_only_impact: affectedMaintainedStories.length === 0,
+        maintained_code_impact: affectedMaintainedStories.length > 0,
+        human_review_required_impact: affectedMaintainedStories.some((item) => item.reviewBoundary?.automation_class !== "safe")
+      },
+      maintained_files_in_scope: stableSortedStrings(affectedMaintainedStories.flatMap((item) => item.maintainedFiles || [])),
+      outputs: affectedMaintainedOutputs,
+      affected_seams: affectedMaintainedSeams,
+      proof_stories: affectedMaintainedStories.map((item) => ({
+        classification: item.classification,
+        relativePath: item.relativePath,
+        maintained_files: item.maintainedFiles || [],
+        review_boundary: item.reviewBoundary
+      }))
+    },
+    affected_verifications: affectedVerifications.map((id) => summarizeById(graph, id) || summarizeById(baselineGraph, id)).filter(Boolean),
+    review_boundary_changes: reviewBoundaryChangeItems,
+    sdlc: sdlcChanges
+  };
+}