@topogram/cli 0.3.64 → 0.3.65

package/src/generator/context/slice.js

@@ -1,860 +1,3 @@
-import {
-  acceptanceCriterionById,
-  bugById,
-  buildDefaultWriteScope,
-  documentById,
-  domainById,
-  ensureContextSelection,
-  getJourneyDoc,
-  getStatement,
-  getWorkflowDoc,
-  pitchById,
-  relatedCapabilitiesForEntity,
-  relatedCapabilitiesForProjection,
-  relatedEntitiesForDomain,
-  relatedJourneysForCapability,
-  relatedProjectionsForCapability,
-  relatedProjectionsForWidget,
-  relatedProjectionsForDomain,
-  relatedProjectionsForEntity,
-  relatedRulesForDomain,
-  relatedRulesForTarget,
-  relatedShapesForWidget,
-  relatedShapesForEntity,
-  relatedShapesForProjection,
-  relatedWidgetsForProjection,
-  relatedVerificationsForDomain,
-  relatedWorkflowDocsForCapability,
-  relatedEntitiesForProjection,
-  recommendedVerificationTargets,
-  requirementById,
-  summarizeAcceptanceCriterion,
-  summarizeBug,
-  summarizeById,
-  summarizeDocsByIds,
-  summarizeDocument,
-  summarizeDomain,
-  summarizePitch,
-  summarizeProjection,
-  summarizeRequirement,
-  summarizeStatementsByIds,
-  summarizeTask,
-  taskById,
-  verificationIdsForTarget,
-  widgetById
-} from "./shared.js";
-import {
-  defaultOwnershipBoundary,
-  reviewBoundaryForAcceptanceCriterion,
-  reviewBoundaryForBug,
-  reviewBoundaryForCapability,
-  reviewBoundaryForDocument,
-  reviewBoundaryForDomain,
-  reviewBoundaryForEntity,
-  reviewBoundaryForJourneyDoc,
-  reviewBoundaryForPitch,
-  reviewBoundaryForRequirement,
-  reviewBoundaryForTask,
-  reviewBoundaryForWorkflowDoc
-} from "../../policy/review-boundaries.js";
+// @ts-check
 
-function capabilitySlice(graph, capabilityId) {
-  const capability = getStatement(graph, "capability", capabilityId);
-  const shapes = [...new Set([...(capability.input || []).map((item) => item.id), ...(capability.output || []).map((item) => item.id)])].sort();
-  const entities = [...new Set([
-    ...(capability.reads || []).map((item) => item.id),
-    ...(capability.creates || []).map((item) => item.id),
-    ...(capability.updates || []).map((item) => item.id),
-    ...(capability.deletes || []).map((item) => item.id)
-  ])].sort();
-  const rules = relatedRulesForTarget(graph, capabilityId);
-  const workflows = relatedWorkflowDocsForCapability(graph, capabilityId).map((doc) => doc.id).sort();
-  const projections = relatedProjectionsForCapability(graph, capabilityId);
-  const journeys = relatedJourneysForCapability(graph, capabilityId).map((doc) => doc.id).sort();
-  const verifications = verificationIdsForTarget(graph, [capabilityId, ...projections, ...shapes, ...entities]);
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: {
-      kind: "capability",
-      id: capabilityId
-    },
-    summary: summarizeById(graph, capabilityId),
-    depends_on: {
-      shapes,
-      entities,
-      rules,
-      workflows,
-      projections,
-      journeys,
-      verifications
-    },
-    related: {
-      shapes: summarizeStatementsByIds(graph, shapes),
-      entities: summarizeStatementsByIds(graph, entities),
-      rules: summarizeStatementsByIds(graph, rules),
-      workflows: summarizeDocsByIds(graph, workflows),
-      journeys: summarizeDocsByIds(graph, journeys),
-      projections: summarizeStatementsByIds(graph, projections)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [capabilityId, ...projections, ...shapes, ...entities], {
-      rationale: "Capability slice should point agents at the smallest verification set covering affected API/UI/DB surfaces."
-    }),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForCapability(capability),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function workflowSlice(graph, workflowId) {
-  const workflow = getWorkflowDoc(graph, workflowId);
-  const capabilities = [...(workflow.relatedCapabilities || [])].sort();
-  const entities = [...new Set(capabilities.flatMap((capabilityId) => {
-    const capability = getStatement(graph, "capability", capabilityId);
-    return [
-      ...(capability.reads || []).map((item) => item.id),
-      ...(capability.creates || []).map((item) => item.id),
-      ...(capability.updates || []).map((item) => item.id),
-      ...(capability.deletes || []).map((item) => item.id)
-    ];
-  }))].sort();
-  const rules = [...new Set(capabilities.flatMap((capabilityId) => relatedRulesForTarget(graph, capabilityId)))].sort();
-  const journeys = (graph.docs || [])
-    .filter((doc) => doc.kind === "journey" && (doc.relatedWorkflows || []).includes(workflowId))
-    .map((doc) => doc.id)
-    .sort();
-  const verifications = verificationIdsForTarget(graph, [...capabilities, ...entities, workflowId]);
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: {
-      kind: "workflow",
-      id: workflowId
-    },
-    summary: summarizeById(graph, workflowId),
-    depends_on: {
-      capabilities,
-      entities,
-      rules,
-      journeys,
-      verifications
-    },
-    related: {
-      capabilities: summarizeStatementsByIds(graph, capabilities),
-      entities: summarizeStatementsByIds(graph, entities),
-      rules: summarizeStatementsByIds(graph, rules),
-      journeys: summarizeDocsByIds(graph, journeys)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [...capabilities, ...entities, workflowId], {
-      rationale: "Workflow changes should re-run workflow-linked verification and human review on semantic behavior."
-    }),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForWorkflowDoc(workflow),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function projectionSlice(graph, projectionId) {
-  const projection = getStatement(graph, "projection", projectionId);
-  const capabilities = relatedCapabilitiesForProjection(projection);
-  const entities = relatedEntitiesForProjection(projection);
-  const shapes = relatedShapesForProjection(projection);
-  const widgets = relatedWidgetsForProjection(graph, projection);
-  const rules = [...new Set(capabilities.flatMap((capabilityId) => relatedRulesForTarget(graph, capabilityId)))].sort();
-  const verifications = verificationIdsForTarget(graph, [projectionId, ...capabilities, ...entities, ...shapes, ...widgets]);
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: {
-      kind: "projection",
-      id: projectionId
-    },
-    summary: summarizeProjection(projection),
-    depends_on: {
-      entities,
-      shapes,
-      capabilities,
-      widgets,
-      rules,
-      verifications
-    },
-    related: {
-      entities: summarizeStatementsByIds(graph, entities),
-      shapes: summarizeStatementsByIds(graph, shapes),
-      capabilities: summarizeStatementsByIds(graph, capabilities),
-      widgets: summarizeStatementsByIds(graph, widgets),
-      rules: summarizeStatementsByIds(graph, rules)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [projectionId, ...capabilities, ...entities, ...shapes, ...widgets], {
-      rationale: "Projection slices affect generated contract and runtime surfaces, so verification should follow the projection closure."
-    }),
-    ui_agent_packet: uiAgentPacketForProjection(graph, projection),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: projection.reviewBoundary || {
-      automation_class: "review_required",
-      reasons: ["projection_surface"]
-    },
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function entitySlice(graph, entityId) {
-  const entity = getStatement(graph, "entity", entityId);
-  const shapes = relatedShapesForEntity(graph, entityId);
-  const capabilities = relatedCapabilitiesForEntity(graph, entityId);
-  const rules = [...new Set([
-    ...relatedRulesForTarget(graph, entityId),
-    ...capabilities.flatMap((capabilityId) => relatedRulesForTarget(graph, capabilityId))
-  ])].sort();
-  const projections = relatedProjectionsForEntity(graph, entityId);
-  const verifications = verificationIdsForTarget(graph, [entityId, ...shapes, ...capabilities, ...projections]);
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: {
-      kind: "entity",
-      id: entityId
-    },
-    summary: summarizeById(graph, entityId),
-    depends_on: {
-      shapes,
-      capabilities,
-      rules,
-      projections,
-      verifications
-    },
-    related: {
-      shapes: summarizeStatementsByIds(graph, shapes),
-      capabilities: summarizeStatementsByIds(graph, capabilities),
-      rules: summarizeStatementsByIds(graph, rules),
-      projections: summarizeStatementsByIds(graph, projections)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [entityId, ...shapes, ...capabilities, ...projections], {
-      rationale: "Entity changes usually affect schema, projection, and capability semantics together."
-    }),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForEntity(entity),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function widgetSlice(graph, widgetId) {
-  const widget = widgetById(graph, widgetId);
-  if (!widget) {
-    throw new Error(`No widget found with id '${widgetId}'`);
-  }
-  const dependencyIds = widgetDependencyIdsByKind(widget);
-  const shapes = relatedShapesForWidget(widget);
-  const entities = dependencyIds.entity;
-  const capabilities = dependencyIds.capability;
-  const projections = relatedProjectionsForWidget(graph, widgetId);
-  const widgetDependencies = dependencyIds.widget;
-  const verificationScope = [widgetId, ...shapes, ...entities, ...capabilities, ...projections, ...widgetDependencies];
-  const verifications = verificationIdsForTarget(graph, verificationScope);
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: {
-      kind: "widget",
-      id: widgetId
-    },
-    summary: summarizeById(graph, widgetId),
-    depends_on: {
-      shapes,
-      entities,
-      capabilities,
-      widgets: widgetDependencies,
-      projections,
-      verifications
-    },
-    related: {
-      shapes: summarizeStatementsByIds(graph, shapes),
-      entities: summarizeStatementsByIds(graph, entities),
-      capabilities: summarizeStatementsByIds(graph, capabilities),
-      widgets: summarizeStatementsByIds(graph, widgetDependencies),
-      projections: summarizeStatementsByIds(graph, projections)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, verificationScope, {
-      rationale: "Widget changes affect every related projection, so verification should follow the widget contract closure."
-    }),
-    ui_agent_packet: uiAgentPacketForWidget(graph, widget, projections),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: {
-      automation_class: "review_required",
-      reasons: ["widget_surface"]
-    },
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function widgetDependencyIdsByKind(widget) {
-  const ids = {
-    shape: [],
-    entity: [],
-    capability: [],
-    projection: [],
-    widget: []
-  };
-
-  for (const dependency of widget.dependencies || []) {
-    const kind = widgetDependencyKind(dependency);
-    if (kind && Object.hasOwn(ids, kind)) {
-      ids[kind].push(dependency.id);
-    }
-  }
-
-  return Object.fromEntries(
-    Object.entries(ids).map(([kind, values]) => [kind, [...new Set(values.filter(Boolean))].sort()])
-  );
-}
-
-function widgetDependencyKind(dependency) {
-  if (dependency?.target?.kind) {
-    return dependency.target.kind === "component" ? "widget" : dependency.target.kind;
-  }
-  const id = String(dependency?.id || "");
-  const prefix = id.split("_")[0];
-  if (prefix === "proj") {
-    return "projection";
-  }
-  if (prefix === "cap") {
-    return "capability";
-  }
-  if (prefix === "component") {
-    return "widget";
-  }
-  return prefix || null;
-}
-
-function uiAgentPacketForProjection(graph, projection) {
-  const projectionType = projection.type || projection.type || null;
-  if (projectionType !== "ui_contract" && !String(projectionType || "").endsWith("_surface")) {
-    return null;
-  }
-  const sharedProjection = projectionType === "ui_contract"
-    ? projection
-    : sharedUiProjectionFor(graph, projection);
-  const ownerProjection = sharedProjection || projection;
-  return {
-    type: "ui_agent_packet",
-    version: 1,
-    ownership: {
-      widgetPlacement: "ui_contract",
-      designIntent: "ui_contract",
-      concreteSurfaceOwns: ["routes", "surface_hints"]
-    },
-    sharedProjection: sharedProjection
-      ? {
-          id: sharedProjection.id,
-          name: sharedProjection.name || sharedProjection.id
-        }
-      : null,
-    screens: (ownerProjection.uiScreens || []).map((screen) => ({
-      id: screen.id,
-      kind: screen.kind,
-      title: screen.title || screen.id
-    })),
-    routes: (projection.uiRoutes || []).map((route) => ({
-      screenId: route.screenId,
-      path: route.path
-    })),
-    widgets: (ownerProjection.widgetBindings || []).map((usage) => widgetUsagePacket(usage, ownerProjection)),
-    designTokens: designIntentPacket(ownerProjection),
-    requiredGates: uiRequiredGates(projection.id)
-  };
-}
-
-function uiAgentPacketForWidget(graph, widget, projectionIds) {
-  const projectionSet = new Set(projectionIds);
-  const sourceUsages = [];
-  for (const projection of graph.byKind.projection || []) {
-    for (const usage of projection.widgetBindings || []) {
-      if (usage.widget?.id !== widget.id) continue;
-      const projectionType = projection.type || projection.type || null;
-      sourceUsages.push({
-        projection: {
-          id: projection.id,
-          type: projectionType,
-          ownership: projectionType === "ui_contract" ? "owner" : "concrete"
-        },
-        usage: widgetUsagePacket(usage, projection),
-        designTokens: designIntentPacket(projection)
-      });
-      projectionSet.add(projection.id);
-    }
-  }
-
-  return {
-    type: "ui_agent_packet",
-    version: 1,
-    ownership: {
-      widgetContract: "widget",
-      widgetPlacement: "ui_contract",
-      concreteSurfacesInherit: true
-    },
-    widget: {
-      id: widget.id,
-      name: widget.name || widget.id,
-      category: widget.category || null,
-      patterns: widget.widgetContract?.patterns || [],
-      regions: widget.widgetContract?.regions || [],
-      behaviors: widget.widgetContract?.behaviors || []
-    },
-    sourceUsages,
-    inheritedBy: [...projectionSet]
-      .filter((projectionId) => !sourceUsages.some((entry) => entry.projection.id === projectionId))
-      .sort(),
-    requiredGates: uiRequiredGates(null, widget.id)
-  };
-}
-
-function sharedUiProjectionFor(graph, projection) {
-  for (const reference of projection.realizes || []) {
-    const candidate = (graph.byKind.projection || []).find((entry) => entry.id === reference.id);
-    if ((candidate?.type || candidate?.type) === "ui_contract") {
-      return candidate;
-    }
-  }
-  return null;
-}
-
-function widgetUsagePacket(usage, projection = null) {
-  const screen = (projection?.uiScreens || []).find((entry) => entry.id === usage.screenId) || null;
-  const region = (projection?.uiScreenRegions || []).find((entry) =>
-    entry.screenId === usage.screenId && entry.region === usage.region
-  ) || null;
-  return {
-    screenId: usage.screenId || null,
-    screen: screen
-      ? {
-          id: screen.id,
-          kind: screen.kind || null,
-          title: screen.title || screen.id
-        }
-      : null,
-    region: usage.region || null,
-    regionContract: region
-      ? {
-          name: region.region || null,
-          pattern: region.pattern || null,
-          placement: region.placement || null,
-          title: region.title || null,
-          state: region.state || null,
-          variant: region.variant || null
-        }
-      : null,
-    widgetId: usage.widget?.id || null,
-    dataBindings: (usage.dataBindings || []).map((binding) => ({
-      prop: binding.prop || null,
-      source: binding.source?.id || binding.source || null
-    })),
-    eventBindings: (usage.eventBindings || []).map((binding) => ({
-      event: binding.event || null,
-      action: binding.action || null,
-      target: binding.target?.id || binding.target || null
-    }))
-  };
-}
-
-function designIntentPacket(projection) {
-  return (projection.uiDesign || []).map((entry) => ({
-    key: entry.key,
-    role: entry.role,
-    value: entry.value
-  }));
-}
-
-function uiRequiredGates(projectionId = null, widgetId = null) {
-  return [
-    { command: "topogram check", reason: "Validate shared UI ownership, taxonomy, references, and topology." },
-    {
-      command: `topogram widget check${projectionId ? ` --projection ${projectionId}` : ""}${widgetId ? ` --widget ${widgetId}` : ""}`,
-      reason: "Validate widget placement, props, events, regions, and patterns."
-    },
-    {
-      command: `topogram widget behavior${projectionId ? ` --projection ${projectionId}` : ""}${widgetId ? ` --widget ${widgetId}` : ""}`,
-      reason: "Inspect behavior realizations and partial bindings before code changes."
-    }
-  ];
-}
-
-function journeySlice(graph, journeyId) {
-  const journey = getJourneyDoc(graph, journeyId);
-  const capabilities = [...(journey.relatedCapabilities || [])].sort();
-  const workflows = [...(journey.relatedWorkflows || [])].sort();
-  const projections = [...(journey.relatedProjections || [])].sort();
-  const verifications = verificationIdsForTarget(graph, [...capabilities, ...workflows, ...projections, journeyId]);
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: {
-      kind: "journey",
-      id: journeyId
-    },
-    summary: summarizeById(graph, journeyId),
-    depends_on: {
-      capabilities,
-      workflows,
-      projections,
-      verifications
-    },
-    related: {
-      capabilities: summarizeStatementsByIds(graph, capabilities),
-      workflows: summarizeDocsByIds(graph, workflows),
-      projections: summarizeStatementsByIds(graph, projections)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [...capabilities, ...workflows, ...projections, journeyId], {
-      rationale: "Journey slices should target workflow-facing verification rather than a full workspace rerun."
-    }),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForJourneyDoc(journey),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function domainSlice(graph, domainId) {
-  const domain = domainById(graph, domainId);
-  if (!domain) {
-    throw new Error(`No domain found with id '${domainId}'`);
-  }
-  const capabilities = [...(domain.members?.capabilities || [])].sort();
-  const entities = relatedEntitiesForDomain(graph, domainId);
-  const rules = relatedRulesForDomain(graph, domainId);
-  const verifications = relatedVerificationsForDomain(graph, domainId);
-  const orchestrations = [...(domain.members?.orchestrations || [])].sort();
-  const operations = [...(domain.members?.operations || [])].sort();
-  const decisions = [...(domain.members?.decisions || [])].sort();
-  const projections = relatedProjectionsForDomain(graph, domainId);
-
-  // Verification targets cover the union of capability/entity/projection IDs in
-  // the domain so a domain-scoped change re-runs the right verification set
-  // without pulling in the whole workspace.
-  const verificationTargets = recommendedVerificationTargets(
-    graph,
-    [domainId, ...capabilities, ...entities, ...projections],
-    {
-      rationale:
-        "Domain slices should re-run verification covering the domain's capabilities, entities, and projection types."
-    }
-  );
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: {
-      kind: "domain",
-      id: domainId
-    },
-    summary: summarizeDomain(domain),
-    depends_on: {
-      capabilities,
-      entities,
-      rules,
-      verifications,
-      orchestrations,
-      operations,
-      decisions,
-      projections
-    },
-    related: {
-      capabilities: summarizeStatementsByIds(graph, capabilities),
-      entities: summarizeStatementsByIds(graph, entities),
-      rules: summarizeStatementsByIds(graph, rules),
-      orchestrations: summarizeStatementsByIds(graph, orchestrations),
-      operations: summarizeStatementsByIds(graph, operations),
-      decisions: summarizeStatementsByIds(graph, decisions),
-      projections: summarizeStatementsByIds(graph, projections)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: verificationTargets,
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForDomain(),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-// Phase 2 — SDLC slices.
-//
-// SDLC slices follow the same shape as feature slices: focus + summary +
-// depends_on + related + verification + write_scope + review_boundary. They
-// give an agent a single payload covering an artifact's chain (pitch →
-// requirement → AC → task → bug → verification → document) without
-// re-walking the graph.
-
-function pitchSlice(graph, pitchId) {
-  const pitch = pitchById(graph, pitchId);
-  if (!pitch) throw new Error(`No pitch found with id '${pitchId}'`);
-
-  const requirements = (pitch.requirements || []).slice().sort();
-  const decisions = [
-    ...(pitch.decisions || []).map((d) => (typeof d === "string" ? d : d?.id)).filter(Boolean),
-    ...(pitch.decisionsFromPitch || [])
-  ];
-  const decisionIds = [...new Set(decisions)].sort();
-  const affects = (pitch.affects || []).map((a) => (typeof a === "string" ? a : a?.id)).filter(Boolean).sort();
-  const verifications = verificationIdsForTarget(graph, [pitchId, ...affects]);
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: { kind: "pitch", id: pitchId },
-    summary: summarizePitch(pitch),
-    depends_on: {
-      requirements,
-      decisions: decisionIds,
-      affects,
-      verifications
-    },
-    related: {
-      requirements: summarizeStatementsByIds(graph, requirements),
-      decisions: summarizeStatementsByIds(graph, decisionIds),
-      affects: summarizeStatementsByIds(graph, affects)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [pitchId, ...affects], {
-      rationale: "Pitch slice covers verification touching any of its affected surfaces."
-    }),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForPitch(),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function requirementSlice(graph, requirementId) {
-  const req = requirementById(graph, requirementId);
-  if (!req) throw new Error(`No requirement found with id '${requirementId}'`);
-
-  const acceptance = (req.acceptanceCriteria || []).slice().sort();
-  const tasks = (req.tasks || []).slice().sort();
-  const documents = (req.documents || []).slice().sort();
-  const rules = (req.rules || []).slice().sort();
-  const introducesRules = (req.introducesRules || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const respectsRules = (req.respectsRules || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const affects = (req.affects || []).map((a) => (typeof a === "string" ? a : a?.id)).filter(Boolean).sort();
-  const verifications = verificationIdsForTarget(graph, [requirementId, ...affects, ...acceptance]);
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: { kind: "requirement", id: requirementId },
-    summary: summarizeRequirement(req),
-    depends_on: {
-      pitch: req.pitch?.id || null,
-      acceptance_criteria: acceptance,
-      tasks,
-      documents,
-      rules,
-      introduces_rules: introducesRules,
-      respects_rules: respectsRules,
-      affects,
-      verifications
-    },
-    related: {
-      acceptance_criteria: summarizeStatementsByIds(graph, acceptance),
-      tasks: summarizeStatementsByIds(graph, tasks),
-      rules: summarizeStatementsByIds(graph, [...rules, ...introducesRules, ...respectsRules]),
-      affects: summarizeStatementsByIds(graph, affects),
-      documents: summarizeDocsByIds(graph, documents)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [requirementId, ...affects, ...acceptance], {
-      rationale: "Requirement slice covers verification tied to its acceptance criteria and affected surfaces."
-    }),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForRequirement(),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function acceptanceCriterionSlice(graph, acId) {
-  const ac = acceptanceCriterionById(graph, acId);
-  if (!ac) throw new Error(`No acceptance_criterion found with id '${acId}'`);
-
-  const tasks = (ac.tasks || []).slice().sort();
-  const verifications = (ac.verifications || []).slice().sort();
-  const requirementId = ac.requirement?.id || null;
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: { kind: "acceptance_criterion", id: acId },
-    summary: summarizeAcceptanceCriterion(ac),
-    depends_on: {
-      requirement: requirementId,
-      tasks,
-      verifications
-    },
-    related: {
-      tasks: summarizeStatementsByIds(graph, tasks),
-      requirement: requirementId ? summarizeStatementsByIds(graph, [requirementId]) : []
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [acId, ...(requirementId ? [requirementId] : [])], {
-      rationale: "AC slice points at verification proving this acceptance criterion."
-    }),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForAcceptanceCriterion(),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function taskSlice(graph, taskId) {
-  const task = taskById(graph, taskId);
-  if (!task) throw new Error(`No task found with id '${taskId}'`);
-
-  const satisfies = (task.satisfies || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const acRefs = (task.acceptanceRefs || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const blockedBy = (task.blockedBy || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const blocks = (task.blocks || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const affects = (task.affects || []).map((a) => (typeof a === "string" ? a : a?.id)).filter(Boolean).sort();
-  const verifications = verificationIdsForTarget(graph, [taskId, ...affects, ...acRefs]);
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: { kind: "task", id: taskId },
-    summary: summarizeTask(task),
-    depends_on: {
-      satisfies,
-      acceptance_refs: acRefs,
-      blocked_by: blockedBy,
-      blocks,
-      affects,
-      verifications
-    },
-    related: {
-      satisfies: summarizeStatementsByIds(graph, satisfies),
-      acceptance_refs: summarizeStatementsByIds(graph, acRefs),
-      blocked_by: summarizeStatementsByIds(graph, blockedBy),
-      affects: summarizeStatementsByIds(graph, affects)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [taskId, ...affects, ...acRefs], {
-      rationale: "Task slice points at verification covering the surfaces this task touches."
-    }),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForTask(),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function bugSlice(graph, bugId) {
-  const bug = bugById(graph, bugId);
-  if (!bug) throw new Error(`No bug found with id '${bugId}'`);
-
-  const violates = (bug.violates || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const surfacesRule = (bug.surfacesRule || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const fixedIn = (bug.fixedIn || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const fixedInVerification = (bug.fixedInVerification || []).map((r) => (typeof r === "string" ? r : r?.id)).filter(Boolean).sort();
-  const verifiedBy = (bug.verifiedBy || []).slice().sort();
-  const affects = (bug.affects || []).map((a) => (typeof a === "string" ? a : a?.id)).filter(Boolean).sort();
-  const verifications = [...new Set([...fixedInVerification, ...verifiedBy, ...verificationIdsForTarget(graph, [bugId, ...affects])])].sort();
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: { kind: "bug", id: bugId },
-    summary: summarizeBug(bug),
-    depends_on: {
-      violates,
-      surfaces_rule: surfacesRule,
-      fixed_in: fixedIn,
-      fixed_in_verification: fixedInVerification,
-      affects,
-      verifications
-    },
-    related: {
-      violates: summarizeStatementsByIds(graph, violates),
-      affects: summarizeStatementsByIds(graph, affects),
-      fixed_in: summarizeStatementsByIds(graph, fixedIn)
-    },
-    verification: summarizeStatementsByIds(graph, verifications),
-    verification_targets: recommendedVerificationTargets(graph, [bugId, ...affects, ...violates], {
-      rationale: "Bug slice points at verification proving the regression is closed."
-    }),
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForBug(),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-function documentSlice(graph, documentId) {
-  const doc = documentById(graph, documentId);
-  if (!doc) throw new Error(`No document found with id '${documentId}'`);
-
-  const relatedEntities = (doc.relatedEntities || []).slice().sort();
-  const relatedCapabilities = (doc.relatedCapabilities || []).slice().sort();
-  const relatedProjections = (doc.relatedProjections || []).slice().sort();
-  const relatedRules = (doc.relatedRules || []).slice().sort();
-
-  return {
-    type: "context_slice",
-    version: 1,
-    focus: { kind: "document", id: documentId },
-    summary: summarizeDocument(doc),
-    depends_on: {
-      related_entities: relatedEntities,
-      related_capabilities: relatedCapabilities,
-      related_projections: relatedProjections,
-      related_rules: relatedRules
-    },
-    related: {
-      entities: summarizeStatementsByIds(graph, relatedEntities),
-      capabilities: summarizeStatementsByIds(graph, relatedCapabilities),
-      projections: summarizeStatementsByIds(graph, relatedProjections),
-      rules: summarizeStatementsByIds(graph, relatedRules)
-    },
-    verification: [],
-    verification_targets: [],
-    write_scope: buildDefaultWriteScope(),
-    review_boundary: reviewBoundaryForDocument(doc),
-    ownership_boundary: defaultOwnershipBoundary()
-  };
-}
-
-export function generateContextSlice(graph, options = {}) {
-  const selection = ensureContextSelection({
-    capabilityId: options.capabilityId,
-    workflowId: options.workflowId,
-    projectionId: options.projectionId,
-    componentId: options.widgetId || options.componentId,
-    entityId: options.entityId,
-    journeyId: options.journeyId,
-    surfaceId: options.surfaceId,
-    domainId: options.domainId,
-    pitchId: options.pitchId,
-    requirementId: options.requirementId,
-    acceptanceId: options.acceptanceId,
-    taskId: options.taskId,
-    bugId: options.bugId,
-    documentId: options.documentId
-  });
-
-  if (selection.kind === "capability") return capabilitySlice(graph, selection.id);
-  if (selection.kind === "workflow") return workflowSlice(graph, selection.id);
-  if (selection.kind === "projection") return projectionSlice(graph, selection.id);
-  if (selection.kind === "widget") return widgetSlice(graph, selection.id);
-  if (selection.kind === "entity") return entitySlice(graph, selection.id);
-  if (selection.kind === "journey") return journeySlice(graph, selection.id);
-  if (selection.kind === "domain") return domainSlice(graph, selection.id);
-  if (selection.kind === "pitch") return pitchSlice(graph, selection.id);
-  if (selection.kind === "requirement") return requirementSlice(graph, selection.id);
-  if (selection.kind === "acceptance_criterion") return acceptanceCriterionSlice(graph, selection.id);
-  if (selection.kind === "task") return taskSlice(graph, selection.id);
-  if (selection.kind === "bug") return bugSlice(graph, selection.id);
-  if (selection.kind === "document") return documentSlice(graph, selection.id);
-
-  throw new Error(`Unsupported context slice kind '${selection.kind}'`);
-}
+export { generateContextSlice } from "./slice/core.js";