@wildo-ai/platform-core-shared 1.1.4 → 1.1.6

package/dist/esm/workbench/workbench-aspect-resources.custom.shared.schemas.js

@@ -101,6 +101,12 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
         rowsPath: 'marketIcps',
         identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
         edges: [
+            /*
+             * The SELF-edge (#1427): an ICP's `influences` name OTHER ICPs, carried inside objects and
+             * invisible to the registry until it walked one level down. It is what makes a buying group
+             * legible — the economic buyer an end user influences is why both are on record.
+             */
+            { field: 'influencesIcpIds', targetAspectKey: 'market.icp', many: true },
             { field: 'personaIds', targetAspectKey: 'market.persona', many: true },
             { field: 'jobIds', targetAspectKey: 'market.job', many: true },
             { field: 'painIds', targetAspectKey: 'market.pain', many: true },
@@ -316,6 +322,15 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
         identity: WorkbenchAspectIdentityKind.SINGLETON,
         edges: [],
     },
+    {
+        aspectKey: 'brand.audience',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_BRAND_AUDIENCE,
+        rowsPath: 'brandAudiences',
+        identity: WorkbenchAspectIdentityKind.SINGLETON,
+        edges: [
+            { field: 'targetIcpIds', targetAspectKey: 'market.icp', many: true },
+        ],
+    },
     {
         aspectKey: 'brand.asset',
         resourceType: WorkbenchShared_ResourceType.ASPECT_BRAND_ASSET,
@@ -325,6 +340,120 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
             { field: 'derivedFromId', targetAspectKey: 'brand.asset', many: false },
         ],
     },
+    /*
+     * THE COMPLIANCE PROGRAMME (#1431, surfaced #1512). Ten aspects, and the edge set is the point:
+     * an obligation reaches the decision that made it applicable, the assignment that owns it, the
+     * gap that blocks it and the coverage decision that reviewed it — the whole reason this family is
+     * addressable at all.
+     *
+     * SEVERAL registry fields collapse into ONE spine field wherever they share a target, because the
+     * projection joins a reference to the descriptor edge whose target matches. A responsibility
+     * assignment names five distinct ROLE fields and they become one `roleIds` link; the distinction
+     * is not lost, it is on the row, where each field renders under its own word. What the edge
+     * carries is the click-through, which is the same for all five.
+     */
+    {
+        aspectKey: 'compliance-program.scope-selector',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_SCOPE_SELECTOR,
+        rowsPath: 'complianceScopeSelectors',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'compliance-program.applicability-decision',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_APPLICABILITY_DECISION,
+        rowsPath: 'complianceApplicabilityDecisions',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'scopeSelectorId', targetAspectKey: 'compliance-program.scope-selector', many: false },
+        ],
+    },
+    {
+        aspectKey: 'compliance-program.obligation',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_OBLIGATION,
+        rowsPath: 'complianceObligations',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'scopeSelectorIds', targetAspectKey: 'compliance-program.scope-selector', many: true },
+            { field: 'responsibilityAssignmentIds', targetAspectKey: 'compliance-program.responsibility-assignment', many: true },
+            { field: 'reviewOwnerRoleIds', targetAspectKey: 'compliance-program.role-authority', many: true },
+            { field: 'gapIds', targetAspectKey: 'compliance-program.gap', many: true },
+            { field: 'coverageDecisionId', targetAspectKey: 'compliance-program.obligation-coverage-decision', many: false },
+            { field: 'sourceApplicabilityDecisionIds', targetAspectKey: 'compliance-program.applicability-decision', many: true },
+            // A SELF-edge: an obligation may depend on another obligation being met first.
+            { field: 'dependencyObligationIds', targetAspectKey: 'compliance-program.obligation', many: true },
+            { field: 'sharedResponsibilityRuleId', targetAspectKey: 'compliance-program.shared-responsibility-rule', many: false },
+        ],
+    },
+    {
+        aspectKey: 'compliance-program.obligation-coverage-decision',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_COVERAGE_DECISION,
+        rowsPath: 'complianceCoverageDecisions',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'obligationId', targetAspectKey: 'compliance-program.obligation', many: false },
+            { field: 'reviewedByRoleId', targetAspectKey: 'compliance-program.role-authority', many: false },
+        ],
+    },
+    {
+        aspectKey: 'compliance-program.implementation-decision',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_IMPLEMENTATION_DECISION,
+        rowsPath: 'complianceImplementationDecisions',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'scopeSelectorIds', targetAspectKey: 'compliance-program.scope-selector', many: true },
+            { field: 'gapIds', targetAspectKey: 'compliance-program.gap', many: true },
+        ],
+    },
+    {
+        aspectKey: 'compliance-program.responsibility-assignment',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_RESPONSIBILITY_ASSIGNMENT,
+        rowsPath: 'complianceResponsibilityAssignments',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'scopeSelectorId', targetAspectKey: 'compliance-program.scope-selector', many: false },
+            // FIVE registry fields — responsible, operating, evidence-provider, approving, escalation —
+            // one target, so one link. Each renders under its own word on the row.
+            { field: 'roleIds', targetAspectKey: 'compliance-program.role-authority', many: true },
+        ],
+    },
+    {
+        aspectKey: 'compliance-program.gap',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_GAP,
+        rowsPath: 'complianceGaps',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'scopeSelectorId', targetAspectKey: 'compliance-program.scope-selector', many: false },
+            { field: 'ownerRoleId', targetAspectKey: 'compliance-program.role-authority', many: false },
+        ],
+    },
+    {
+        aspectKey: 'compliance-program.documentation-requirement',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_DOCUMENTATION_REQUIREMENT,
+        rowsPath: 'complianceDocumentationRequirements',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'approvingRoleIds', targetAspectKey: 'compliance-program.role-authority', many: true },
+        ],
+    },
+    {
+        aspectKey: 'compliance-program.role-authority',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_ROLE_AUTHORITY,
+        rowsPath: 'complianceRoleAuthorities',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'compliance-program.shared-responsibility-rule',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_SHARED_RESPONSIBILITY_RULE,
+        rowsPath: 'complianceSharedResponsibilityRules',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'scopeSelectorIds', targetAspectKey: 'compliance-program.scope-selector', many: true },
+            // Five role fields again — accountable, operating, evidence-provider, approving, conflict.
+            { field: 'roleIds', targetAspectKey: 'compliance-program.role-authority', many: true },
+        ],
+    },
     {
         aspectKey: 'domain-plan.module',
         resourceType: WorkbenchShared_ResourceType.ASPECT_DOMAIN_PLAN_MODULE,
@@ -332,12 +461,40 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
         identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
         edges: [],
     },
+    /*
+     * The DERIVED resource (#1482, surfaced #1512). Its rows are a projection of
+     * `modules[].mainResources` rather than a member of the snapshot — a domain plan lists resources
+     * as plain strings — and it is the single most-travelled link in the build lane: a build task's
+     * `target.resourceRef` and `produces.resourceRef`, a placement decision's `subject.resourceRef`
+     * and an experience view's `resourceId` all land here. Without this row every one of those was an
+     * edge the graph could declare and not follow.
+     */
+    {
+        aspectKey: 'domain-plan.resource',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_DOMAIN_PLAN_RESOURCE,
+        rowsPath: 'domainPlanResources',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            // Back to the module that lists it — the one edge a projected row carries.
+            { field: 'moduleId', targetAspectKey: 'domain-plan.module', many: false },
+        ],
+    },
     {
         aspectKey: 'domain-plan.relationship',
         resourceType: WorkbenchShared_ResourceType.ASPECT_DOMAIN_PLAN_RELATIONSHIP,
         rowsPath: 'domainPlanRelationships',
         identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
-        edges: [],
+        edges: [
+            /*
+             * The two ENDS, as ONE spine field. The registry declares `sourceResourceRef` and
+             * `targetResourceRef` separately and both land on the same aspect, and the projection joins a
+             * reference to the descriptor edge whose target matches — so one target is one field, by
+             * construction. The DIRECTION is not lost: it is on the row itself, where `sourceResourceRef`
+             * and `targetResourceRef` render as "From" and "To"; what this field carries is the
+             * click-through, which is the same for both ends.
+             */
+            { field: 'relatesResourceIds', targetAspectKey: 'domain-plan.resource', many: true },
+        ],
     },
     {
         aspectKey: 'build-plan.task',
@@ -346,11 +503,218 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
         identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
         edges: [
             { field: 'prerequisiteTaskIds', targetAspectKey: 'build-plan.task', many: true },
+            /*
+             * THE LINK BACK TO THE DECISION (#1427): a task's `target` names the domain-plan module or
+             * relationship it builds. Carried inside an object, so the registry could not see it until its
+             * drift pin walked one level down — and the spine could not link it until the registry did.
+             */
+            { field: 'targetModuleId', targetAspectKey: 'domain-plan.module', many: false },
+            { field: 'targetRelationshipId', targetAspectKey: 'domain-plan.relationship', many: false },
+            /*
+             * The most-travelled link in the build lane (#1482): a task's `target.resourceRef` and its
+             * `produces.resourceRef` both name the resource it builds. Two registry fields, one target,
+             * so one spine field — what is built and what it produces are the same resource.
+             */
+            { field: 'resourceIds', targetAspectKey: 'domain-plan.resource', many: true },
+            /* A task may serve a DRAFTED FEATURE (#1433 row 4) — declared once the data was measured. */
+            { field: 'servesFeatureDraftIds', targetAspectKey: 'feature-drafts.draft', many: true },
+            { field: 'servesFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
+            { field: 'servesNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
+            { field: 'servesRoadmapPhaseIds', targetAspectKey: 'roadmap.phase', many: true },
+            /* The vision edges (#629) — see the registry for why a build task may serve these. */
+            { field: 'servesSuccessCriterionIds', targetAspectKey: 'vision.success-criterion', many: true },
+            { field: 'servesConstraintIds', targetAspectKey: 'vision.constraint', many: true },
+            /*
+             * The experience plan's entries on the PRODUCT side (#1660): a view, milestone or guidance task
+             * names the entry it builds by the plan's own ref, so the task links to the decision.
+             */
+            { field: 'producesViewIds', targetAspectKey: 'experience-plan.view', many: true },
+            { field: 'producesMilestoneIds', targetAspectKey: 'experience-plan.milestone', many: true },
+            { field: 'producesGuidanceIds', targetAspectKey: 'experience-plan.guidance', many: true },
+            /* A billing-catalogue task names the pricing plan it realises in `servesRefs` (#1835). */
+            { field: 'servesPricingPlanIds', targetAspectKey: 'business-model.plan', many: true },
+        ],
+    },
+    {
+        /*
+         * One composition decision per framework scenario (#1491) — NO edges: a decision names a
+         * SCENARIO (a framework template) and a basis (a closed vocabulary), neither of which is a
+         * decided element another aspect addresses.
+         */
+        aspectKey: 'capability-composition.decision',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_CAPABILITY_COMPOSITION_DECISION,
+        rowsPath: 'compositionDecisions',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        /*
+         * One planned website page (#1492). Its two edges reach the MARKET — a page is written for an
+         * ICP, in a tone of voice — which is what makes the plan checkable from the snapshot's side.
+         */
+        aspectKey: 'website-plan.page',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_WEBSITE_PAGE,
+        rowsPath: 'websitePages',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'audienceIcpIds', targetAspectKey: 'market.icp', many: true },
+            { field: 'toneOfVoiceId', targetAspectKey: 'market.tone-of-voice', many: false },
+        ],
+    },
+    {
+        /* One planned surface of the application's experience (#1493) — where it lives, and what asked for it. */
+        aspectKey: 'experience-plan.view',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_EXPERIENCE_VIEW,
+        rowsPath: 'experienceViews',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'moduleId', targetAspectKey: 'domain-plan.module', many: false },
+            { field: 'resourceId', targetAspectKey: 'domain-plan.resource', many: false },
+            { field: 'servesFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
+            { field: 'servesNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
+            { field: 'servesRoadmapPhaseIds', targetAspectKey: 'roadmap.phase', many: true },
+            { field: 'servesFeatureDraftIds', targetAspectKey: 'feature-drafts.draft', many: true },
+            { field: 'servesSuccessCriterionIds', targetAspectKey: 'vision.success-criterion', many: true },
+        ],
+    },
+    {
+        /* One configuration surface the application composes — no edge: it names files and tokens, not elements. */
+        aspectKey: 'experience-plan.configuration',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_EXPERIENCE_CONFIGURATION,
+        rowsPath: 'experienceConfigurations',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        /* One moment the application recognises — the module declaring it and the resource that earns it. */
+        aspectKey: 'experience-plan.milestone',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_EXPERIENCE_MILESTONE,
+        rowsPath: 'experienceMilestones',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'moduleId', targetAspectKey: 'domain-plan.module', many: false },
+            { field: 'triggerResourceId', targetAspectKey: 'domain-plan.resource', many: false },
             { field: 'servesFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
             { field: 'servesNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
             { field: 'servesRoadmapPhaseIds', targetAspectKey: 'roadmap.phase', many: true },
+            { field: 'servesFeatureDraftIds', targetAspectKey: 'feature-drafts.draft', many: true },
+            { field: 'servesSuccessCriterionIds', targetAspectKey: 'vision.success-criterion', many: true },
         ],
     },
+    {
+        /* One piece of guidance, linked to the milestones a person must hold first — the journey as one path. */
+        aspectKey: 'experience-plan.guidance',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_EXPERIENCE_GUIDANCE,
+        rowsPath: 'experienceGuidance',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'moduleId', targetAspectKey: 'domain-plan.module', many: false },
+            { field: 'gatedByMilestoneIds', targetAspectKey: 'experience-plan.milestone', many: true },
+            { field: 'hostViewId', targetAspectKey: 'experience-plan.view', many: false },
+            { field: 'servesFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
+            { field: 'servesNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
+            { field: 'servesRoadmapPhaseIds', targetAspectKey: 'roadmap.phase', many: true },
+            { field: 'servesFeatureDraftIds', targetAspectKey: 'feature-drafts.draft', many: true },
+            { field: 'servesSuccessCriterionIds', targetAspectKey: 'vision.success-criterion', many: true },
+        ],
+    },
+    {
+        /*
+         * One worker the backend delegates to (#1495). Its only edges are what asked for it: a worker's
+         * routes are the BUILT package's units of work, not decided elements.
+         */
+        aspectKey: 'integration-plan.worker',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_INTEGRATION_WORKER,
+        rowsPath: 'integrationWorkers',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'servesFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
+            { field: 'servesNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
+            { field: 'servesRoadmapPhaseIds', targetAspectKey: 'roadmap.phase', many: true },
+            { field: 'servesFeatureDraftIds', targetAspectKey: 'feature-drafts.draft', many: true },
+            { field: 'servesSuccessCriterionIds', targetAspectKey: 'vision.success-criterion', many: true },
+        ],
+    },
+    {
+        /*
+         * One cron minion (#1495) — and the ONE aspect whose edges are not unique by target: its
+         * containment whitelist reaches `domain-plan.resource` TWICE, once per direction, so both
+         * carry `sourceField`. The direction is the decision, and collapsing the two would report a
+         * minion as reading what it only writes.
+         */
+        aspectKey: 'integration-plan.minion',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_INTEGRATION_MINION,
+        rowsPath: 'integrationMinions',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'readsResourceIds', sourceField: 'readsResourceRefs', targetAspectKey: 'domain-plan.resource', many: true },
+            { field: 'writesResourceIds', sourceField: 'writesResourceRefs', targetAspectKey: 'domain-plan.resource', many: true },
+            { field: 'servesFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
+            { field: 'servesNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
+            { field: 'servesRoadmapPhaseIds', targetAspectKey: 'roadmap.phase', many: true },
+            { field: 'servesFeatureDraftIds', targetAspectKey: 'feature-drafts.draft', many: true },
+            { field: 'servesSuccessCriterionIds', targetAspectKey: 'vision.success-criterion', many: true },
+        ],
+    },
+    {
+        /* One provider bound into one scope — no edge: a provider ref is the ENGINE's catalogue, not a decided element. */
+        aspectKey: 'integration-plan.provider-binding',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_INTEGRATION_PROVIDER_BINDING,
+        rowsPath: 'integrationProviderBindings',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        /* One channel work arrives on (#1630). Its only edges are what asked for it, like a worker's. */
+        aspectKey: 'integration-plan.inbound-channel',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_INTEGRATION_INBOUND_CHANNEL,
+        rowsPath: 'integrationInboundChannels',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'servesFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
+            { field: 'servesNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
+            { field: 'servesRoadmapPhaseIds', targetAspectKey: 'roadmap.phase', many: true },
+            { field: 'servesFeatureDraftIds', targetAspectKey: 'feature-drafts.draft', many: true },
+            { field: 'servesSuccessCriterionIds', targetAspectKey: 'vision.success-criterion', many: true },
+        ],
+    },
+    {
+        /*
+         * One requirement's standing (#1496), and the aspect that carries BOTH multi-edge shapes at
+         * once — which is why every edge here names its source field.
+         *
+         * Its business key IS its edge: the row exists to say something about ONE requirement, and
+         * `requirementRef` reaches both halves of the family — one field, two targets — routed by
+         * MEMBERSHIP rather than by the row's own `half` field, which it does carry. An aspect edge
+         * declares its targets ONCE and has no per-row selection, and membership MEASURES where a ref
+         * lives instead of trusting a landed file's claim about it. `landedTaskIds` and
+         * `provenTaskIds` are the other shape, two fields to ONE target, and they must stay apart
+         * because proven is a subset of landed and collapsing them would report work as verified that
+         * only exists.
+         *
+         * The projection therefore joins on the PAIR. Naming the source field on all four is what makes
+         * that join load-bearing rather than incidental: with them omitted the target-only fallback
+         * happens to resolve the same rows, and a regression in the join would go unnoticed.
+         */
+        aspectKey: 'application-maturity.requirement',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_REQUIREMENT_MATURITY,
+        rowsPath: 'requirementMaturities',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'functionalRequirementId', sourceField: 'requirementRef', targetAspectKey: 'requirements.functional', many: false },
+            { field: 'nonFunctionalRequirementId', sourceField: 'requirementRef', targetAspectKey: 'requirements.non-functional', many: false },
+            { field: 'landedTaskIds', sourceField: 'landedTaskRefs', targetAspectKey: 'build-plan.task', many: true },
+            { field: 'provenTaskIds', sourceField: 'provenTaskRefs', targetAspectKey: 'build-plan.task', many: true },
+        ],
+    },
+    {
+        /* One planned documentation chapter (#1494) — no edge: it cites the BUILT product's own specifications. */
+        aspectKey: 'documentation-plan.chapter',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_DOCUMENTATION_CHAPTER,
+        rowsPath: 'documentationChapters',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
     {
         aspectKey: 'placement.group',
         resourceType: WorkbenchShared_ResourceType.ASPECT_PLACEMENT_GROUP,
@@ -365,6 +729,13 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
         identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
         edges: [
             { field: 'groupId', targetAspectKey: 'placement.group', many: false },
+            /*
+             * A placement decision's SUBJECT is a domain-plan module or a RESOURCE (#1427/#1482), both
+             * carried inside an object. The resource half was the one the graph could not follow until
+             * the projected resource got a row of its own.
+             */
+            { field: 'subjectModuleId', targetAspectKey: 'domain-plan.module', many: false },
+            { field: 'subjectResourceId', targetAspectKey: 'domain-plan.resource', many: false },
         ],
     },
     {
@@ -372,6 +743,10 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
         resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_CANDIDATE_SECTION,
         rowsPath: 'complianceCandidateSections',
         identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        /*
+         * No edges since #1465: the producer family lands into the SET and is never indexed, so its
+         * clause → fact link moved to `compliance-candidate-set.section`, the aspect that is read.
+         */
         edges: [],
     },
     {
@@ -413,6 +788,18 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
         identity: WorkbenchAspectIdentityKind.INDEXED,
         edges: [],
     },
+    {
+        /*
+         * BUSINESS_KEY, unlike the processor entry above: a risk entry carries `entryRef`, which the
+         * family validator holds unique and which `reviewOrder` addresses rows by. An indexed identity
+         * here would make the register's own reading order unable to name the rows it orders.
+         */
+        aspectKey: 'risk-register.entry',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_RISK_REGISTER_ENTRY,
+        rowsPath: 'riskRegisterEntries',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
     {
         aspectKey: 'release-policy.selection',
         resourceType: WorkbenchShared_ResourceType.ASPECT_RELEASE_POLICY_SELECTION,
@@ -427,6 +814,59 @@ export const WORKBENCH_ASPECT_DESCRIPTORS = [
         identity: WorkbenchAspectIdentityKind.INDEXED,
         edges: [],
     },
+    /*
+     * The two landed SET families of the governed-document lane (#1105). A drafting run EMITS one
+     * candidate (the singular family the two `compliance-candidate.*` descriptors above transcribe) and
+     * LANDS into the set; a composed release lands into the release set. Without these two, the set that
+     * actually landed had no popup and no graph row — a journey that drafted the privacy notice showed the
+     * draft's sections only through the producer's contract.
+     */
+    {
+        aspectKey: 'compliance-candidate-set.candidate',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_CANDIDATE,
+        rowsPath: 'complianceCandidates',
+        // Keyed on `documentRef`: the identity decision the set schema records (locale and jurisdictions
+        // are publication-variant concerns and would make a draft's identity change as it matured).
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            /*
+             * These rows CITE facts, and a fact is either DERIVED from the application or DECIDED by a
+             * person — one registry edge with two targets, which the projection routes by membership, so
+             * the spine needs one field per target (#1427).
+             */
+            { field: 'citesFactIds', targetAspectKey: 'document-facts.declaration', many: true },
+            { field: 'citesDecidedFactIds', targetAspectKey: 'document-facts-authored.declaration', many: true },
+        ],
+    },
+    {
+        /*
+         * One SECTION of a landed candidate (#1465), derived from the set's `candidates` and addressed by
+         * the composed `<documentRef>/<sectionRef>` — a section ref alone repeats across documents.
+         */
+        aspectKey: 'compliance-candidate-set.section',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_CANDIDATE_SET_SECTION,
+        rowsPath: 'complianceCandidateSetSections',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            // Back to the candidate the section belongs to.
+            { field: 'complianceCandidateId', targetAspectKey: 'compliance-candidate-set.candidate', many: false },
+            /*
+             * The section's CLAUSES cite the facts they rest on — derived or decided — one registry edge with
+             * two targets, routed by membership, so one spine field per target (#1427).
+             */
+            { field: 'citesFactIds', targetAspectKey: 'document-facts.declaration', many: true },
+            { field: 'citesDecidedFactIds', targetAspectKey: 'document-facts-authored.declaration', many: true },
+        ],
+    },
+    {
+        aspectKey: 'document-release-set.release',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_DOCUMENT_RELEASE,
+        rowsPath: 'documentReleases',
+        // A release is keyed by document × locale × jurisdictions — no single-field business key, so the
+        // registry falls back to the indexed identity, as the publication variant beside it does.
+        identity: WorkbenchAspectIdentityKind.INDEXED,
+        edges: [],
+    },
 ];
 const DESCRIPTOR_BY_ASPECT_KEY = new Map(WORKBENCH_ASPECT_DESCRIPTORS.map((descriptor) => [descriptor.aspectKey, descriptor]));
 export function getWorkbenchAspectDescriptor(aspectKey) {