@wildo-ai/platform-core-shared 1.1.1 → 1.1.2

package/dist/esm/workbench/workbench-resources-types.custom.shared.schemas.d.ts

@@ -10,34 +10,155 @@
  * companion can serve them.
  */
 export declare enum WorkbenchShared_ResourceType {
-    APPLICATION_MODULES = "workbenchApplicationModules",
     /**
-     * Every relationship edge the application's resources declare — how its domain is wired.
+     * The application's domain model as ONE row per resource — module membership, specification prose
+     * and the relationships that resource participates in, all in the same row.
      *
-     * Projected from a DIFFERENT behavior (`resources-registry`) than the modules beside it, which is
-     * what makes it the surface that proves the adapter generalizes: one binding shape, two behaviors,
-     * two row shapes, no adapter change.
+     * ## Why ONE resource rather than a module list beside an edge list
+     *
+     * It replaced exactly that, on 2026-08-31. `workbenchApplicationModules` and
+     * `workbenchResourceRelationships` were projections of DIFFERENT companion behaviors on DIFFERENT
+     * targets, so a graph drawn from both was drawn from two subprocess runs against a working tree an
+     * operator is editing — its nodes could describe one state of the application and its edges the
+     * next, with nothing able to detect it. The `application-domain-model` behavior answers all four
+     * facts from a single import, which is the only shape in which "resources, their relationships and
+     * their module membership" is internally consistent.
+     *
+     * The two were kept for a while on the argument that a flat module list and a flat edge list
+     * answered two narrower questions this one did not. Both were then closed rather than argued: every
+     * per-edge field the relationships table carried — `isDisabled`, `accessScopeStrategy`,
+     * `parentResourceRequirement`, `primaryScope`, `allowCycle` — now rides in
+     * `Workbench_DomainResourceRelationship`, and `isDisabled` in particular was a defect while it was
+     * missing rather than a gap, because the graph drew a disabled edge exactly like a live one.
+     *
+     * One thing genuinely did NOT survive, and it is recorded here rather than in a commit message: a
+     * module registering ZERO resources produces no row, so it has no node. Wonder CRM's `engine`
+     * module is exactly that. The judgement was that a module contributing nothing to the DOMAIN has no
+     * place in a domain model, and that engine-scaffolding modules are what
+     * `workbenchSpecificationArtifacts` is for — not that the case was overlooked.
+     */
+    DOMAIN_RESOURCES = "workbenchDomainResources",
+    /**
+     * Every application-specification family the journey produces that is NOT the application's own
+     * structure — the vision, the market, the requirements, the roadmap, the obligations — as one row
+     * each, carrying the artifact rendered for a human to read.
+     *
+     * ## Why the PRODUCT half needed its own resource
+     *
+     * The three siblings above all project the application's STRUCTURE: modules, edges, resources.
+     * None of them can carry a vision brief, because a vision brief is not a resource, an edge or a
+     * module — it is a prose document about the product the application is meant to be. Those
+     * documents were reachable only by opening a TypeScript file in an editor, which is not a product
+     * (issue #162).
+     *
+     * ## Why one resource rather than one per family
+     *
+     * The families are heterogeneous, and the two failure modes are symmetric: one destination per
+     * family risks a dozen half-built pages, one destination navigating all of them risks a
+     * lowest-common-denominator renderer. The answer taken is one destination whose rows are DERIVED
+     * from `APPLICATION_SPECIFICATION_SEMANTIC_SCHEMA_BINDINGS` — so the population cannot drift from
+     * the authority — grouped by the question each family answers, with an outline renderer as the
+     * floor and the artifacts already committed beside a family (`DIAGRAM.md`, `DECISIONS.md`)
+     * surfaced verbatim on top of it. The decision and its rejected alternatives are recorded on
+     * issue #162.
+     */
+    SPECIFICATION_ARTIFACTS = "workbenchSpecificationArtifacts",
+    /**
+     * One row per compiled playbook, carrying its ELIGIBILITY VERDICT — can it run right now, and if
+     * not, why not — plus the overwrite/stale annotations a creator weighs before dispatching.
+     *
+     * The rows are a projection of `listPlaybookEligibility()`, the ~10s recompute the creation
+     * board's Playbooks pane renders; the companion serves them through a `{board, computedAt}` cache
+     * so resource-surface consumers (RMM, lists) do not multiply the recompute. `computedAt` and the
+     * derived journey `phase` are projected onto every row — board-level scalars become row fields,
+     * because a resource row must be complete on its own.
+     */
+    PLAYBOOKS = "workbenchPlaybooks",
+    /**
+     * One row per build-plan task, in the DISPATCH view: its status (`ready` / `landed` / `blocked`),
+     * objective and target kind.
+     *
+     * DELIBERATELY THIN beside `ASPECT_BUILD_TASK` (`workbenchBuildTasks`), which projects the SAME
+     * authored population from the specification artifact with its traceability edges. The two answer
+     * different questions — the aspect answers "what did the journey author" (subprocess, from the
+     * artifact), this one answers "what can the dispatcher run next and what has landed" (in-process,
+     * computed against git by the dispatch service). Authored detail (skillRefs, serves edges) stays
+     * on the aspect row sharing the same `taskRef`; duplicating it here would be a second enumeration
+     * of the authored shape, one drift away from lying.
+     */
+    BUILD_PLAN_TASKS = "workbenchBuildPlanTasks",
+    /**
+     * One row per playbook run's WRITE RECORD — which files it wrote, with `existedBefore` per file —
+     * the evidence lane that makes every dispatch on the creation board revertable. Pre-image BYTES
+     * are deliberately not projected (they belong to the revert mechanism, not to a list row).
      */
-    RESOURCE_RELATIONSHIPS = "workbenchResourceRelationships"
+    RUN_WRITE_RECORDS = "workbenchRunWriteRecords",
+    /**
+     * One row per execution-trace session — the session id, when it started, and how many events and
+     * steps it recorded. The detail (events, artifacts) stays on the companion's trace routes for
+     * now; this resource is the queryable index the board links from.
+     */
+    TRACE_SESSIONS = "workbenchTraceSessions",
+    ASPECT_VISION_IDEA = "workbenchVisionIdeas",
+    ASPECT_VISION_PROBLEM = "workbenchVisionProblems",
+    ASPECT_VISION_MISSION = "workbenchVisionMissions",
+    ASPECT_VISION_SUCCESS_CRITERION = "workbenchVisionSuccessCriteria",
+    ASPECT_VISION_CONSTRAINT = "workbenchVisionConstraints",
+    ASPECT_MARKET_CATEGORY = "workbenchMarketCategories",
+    ASPECT_MARKET_ICP = "workbenchMarketIcps",
+    ASPECT_MARKET_PERSONA = "workbenchMarketPersonas",
+    ASPECT_MARKET_JOB = "workbenchMarketJobs",
+    ASPECT_MARKET_PAIN = "workbenchMarketPains",
+    ASPECT_MARKET_GAIN = "workbenchMarketGains",
+    ASPECT_MARKET_TONE_OF_VOICE = "workbenchMarketTonesOfVoice",
+    ASPECT_MARKET_BENEFIT = "workbenchMarketBenefits",
+    ASPECT_MARKET_POSITIONING = "workbenchMarketPositionings",
+    ASPECT_MARKET_CHANNEL = "workbenchMarketChannels",
+    ASPECT_MARKET_ALTERNATIVE = "workbenchMarketAlternatives",
+    ASPECT_MARKET_TRIGGER = "workbenchMarketTriggers",
+    ASPECT_MARKET_BUYING_JOURNEY = "workbenchMarketBuyingJourneys",
+    ASPECT_MARKET_PROOF = "workbenchMarketProofs",
+    ASPECT_MARKET_OBJECTION = "workbenchMarketObjections",
+    ASPECT_MARKET_MESSAGE_TEMPLATE = "workbenchMarketMessageTemplates",
+    ASPECT_REQUIREMENT_FUNCTIONAL = "workbenchFunctionalRequirements",
+    ASPECT_REQUIREMENT_NON_FUNCTIONAL = "workbenchNonFunctionalRequirements",
+    ASPECT_FEATURE_DRAFT = "workbenchFeatureDrafts",
+    ASPECT_ROADMAP_PHASE = "workbenchRoadmapPhases",
+    ASPECT_PRICING_PLAN = "workbenchPricingPlans",
+    ASPECT_BRAND_NAME = "workbenchBrandNames",
+    ASPECT_BRAND_LOGO_DIRECTION = "workbenchBrandLogoDirections",
+    ASPECT_BRAND_VISUAL_TONE = "workbenchBrandVisualTones",
+    ASPECT_BRAND_ASSET = "workbenchBrandAssets",
+    ASPECT_DOMAIN_PLAN_MODULE = "workbenchDomainPlanModules",
+    ASPECT_DOMAIN_PLAN_RELATIONSHIP = "workbenchDomainPlanRelationships",
+    ASPECT_BUILD_TASK = "workbenchBuildTasks",
+    ASPECT_PLACEMENT_GROUP = "workbenchPlacementGroups",
+    ASPECT_PLACEMENT_DECISION = "workbenchPlacementDecisions",
+    ASPECT_COMPLIANCE_CANDIDATE_SECTION = "workbenchComplianceCandidateSections",
+    ASPECT_COMPLIANCE_CANDIDATE_VARIANT_SELECTION = "workbenchComplianceCandidateVariantSelections",
+    ASPECT_DOCUMENT_FACT_DECLARATION = "workbenchDocumentFactDeclarations",
+    ASPECT_AUTHORED_DOCUMENT_FACT_DECLARATION = "workbenchAuthoredDocumentFactDeclarations",
+    ASPECT_PROCESSOR_REGISTER_ENTRY = "workbenchProcessorRegisterEntries",
+    ASPECT_RELEASE_POLICY_SELECTION = "workbenchReleasePolicySelections",
+    ASPECT_DOCUMENT_PUBLICATION_VARIANT = "workbenchDocumentPublicationVariants"
 }
 /**
  * The field each resource is ADDRESSED BY — and it must be a field the rows actually carry.
  *
- * `workbenchApplicationModules` is identified by `moduleId`, not by a composed
- * `workbenchApplicationModuleId`. The convention-shaped name was declared here first and no row ever
- * carried it: the schema marks `moduleId` as the primary key, the behavior emits `moduleId`, and
- * `identityFields: ['moduleId']` composes the id from it. Nothing anywhere produced the other name,
- * so every consumer that addresses a row THROUGH this map looked for a field that did not exist.
- *
- * READ still worked, which is what kept it hidden: the adapter filters by `identityFields`, so
- * `GET …/workbench-application-modules/engine` answered 200 while the frontend list refused every
- * row click with "could not resolve resource id from list item" — the id it was told to read was
- * absent from the item.
- *
- * Its sibling is the contrast that settles the rule rather than an inconsistency: an edge has no
- * natural key, so `workbenchResourceRelationshipId` is SYNTHESIZED from three fields and is a real
- * declared field of the schema, present on every row. Both entries now name something real; one
- * happens to be the source's own key and the other is composed.
+ * ## The rule, and the defect that produced it
+ *
+ * A convention-shaped name declared here that no row carries makes every consumer addressing a row
+ * THROUGH this map look for a field that does not exist. The resource this was measured on
+ * (`workbenchApplicationModules`, removed 2026-08-31) declared `workbenchApplicationModuleId` while
+ * its schema, its behavior and its `identityFields` all said `moduleId`.
+ *
+ * READ still worked, which is what kept it hidden: the adapter filters by `identityFields`, so the
+ * addressed route answered 200 while the frontend list refused every row click with "could not
+ * resolve resource id from list item" — the id it was told to read was absent from the item. A green
+ * addressed READ is therefore NOT evidence that this map is right; the list row click is.
+ *
+ * So an entry here is either the source's OWN key, or a name COMPOSED by `identityFields` and
+ * declared as a real field of the schema. Never a name that merely follows the convention.
  */
 export declare const WorkbenchShared_ResourceFieldIdentifier: {
     [key in WorkbenchShared_ResourceType]: string;

package/dist/esm/workbench/workbench-resources-types.custom.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workbench-resources-types.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/workbench/workbench-resources-types.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,oBAAY,4BAA4B;IACtC,mBAAmB,gCAAgC;IACnD;;;;;;OAMG;IACH,sBAAsB,mCAAmC;CAC1D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uCAAuC,EAAE;KAAG,GAAG,IAAI,4BAA4B,GAAG,MAAM;CAGpG,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B,mCAAmC,CAAC"}
+{"version":3,"file":"workbench-resources-types.custom.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/workbench/workbench-resources-types.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,oBAAY,4BAA4B;IACtC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBAAgB,6BAA6B;IAC7C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBAAuB,oCAAoC;IA6B3D;;;;;;;;;OASG;IACH,SAAS,uBAAuB;IAChC;;;;;;;;;;;OAWG;IACH,gBAAgB,4BAA4B;IAC5C;;;;OAIG;IACH,iBAAiB,6BAA6B;IAC9C;;;;OAIG;IACH,cAAc,2BAA2B;IACzC,kBAAkB,yBAAyB;IAC3C,qBAAqB,4BAA4B;IACjD,qBAAqB,4BAA4B;IACjD,+BAA+B,mCAAmC;IAClE,wBAAwB,+BAA+B;IACvD,sBAAsB,8BAA8B;IACpD,iBAAiB,wBAAwB;IACzC,qBAAqB,4BAA4B;IACjD,iBAAiB,wBAAwB;IACzC,kBAAkB,yBAAyB;IAC3C,kBAAkB,yBAAyB;IAC3C,2BAA2B,gCAAgC;IAC3D,qBAAqB,4BAA4B;IACjD,yBAAyB,gCAAgC;IACzD,qBAAqB,4BAA4B;IACjD,yBAAyB,gCAAgC;IACzD,qBAAqB,4BAA4B;IACjD,4BAA4B,kCAAkC;IAC9D,mBAAmB,0BAA0B;IAC7C,uBAAuB,8BAA8B;IACrD,8BAA8B,oCAAoC;IAClE,6BAA6B,oCAAoC;IACjE,iCAAiC,uCAAuC;IACxE,oBAAoB,2BAA2B;IAC/C,oBAAoB,2BAA2B;IAC/C,mBAAmB,0BAA0B;IAC7C,iBAAiB,wBAAwB;IACzC,2BAA2B,iCAAiC;IAC5D,wBAAwB,8BAA8B;IACtD,kBAAkB,yBAAyB;IAC3C,yBAAyB,+BAA+B;IACxD,+BAA+B,qCAAqC;IACpE,iBAAiB,wBAAwB;IACzC,sBAAsB,6BAA6B;IACnD,yBAAyB,gCAAgC;IACzD,mCAAmC,yCAAyC;IAC5E,6CAA6C,kDAAkD;IAC/F,gCAAgC,sCAAsC;IACtE,yCAAyC,8CAA8C;IACvF,+BAA+B,sCAAsC;IACrE,+BAA+B,qCAAqC;IACpE,mCAAmC,yCAAyC;CAC7E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,uCAAuC,EAAE;KAAG,GAAG,IAAI,4BAA4B,GAAG,MAAM;CAoFpG,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B,mCAAmC,CAAC"}

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

@@ -11,38 +11,267 @@
  */
 export var WorkbenchShared_ResourceType;
 (function (WorkbenchShared_ResourceType) {
-    WorkbenchShared_ResourceType["APPLICATION_MODULES"] = "workbenchApplicationModules";
     /**
-     * Every relationship edge the application's resources declare — how its domain is wired.
+     * The application's domain model as ONE row per resource — module membership, specification prose
+     * and the relationships that resource participates in, all in the same row.
      *
-     * Projected from a DIFFERENT behavior (`resources-registry`) than the modules beside it, which is
-     * what makes it the surface that proves the adapter generalizes: one binding shape, two behaviors,
-     * two row shapes, no adapter change.
+     * ## Why ONE resource rather than a module list beside an edge list
+     *
+     * It replaced exactly that, on 2026-08-31. `workbenchApplicationModules` and
+     * `workbenchResourceRelationships` were projections of DIFFERENT companion behaviors on DIFFERENT
+     * targets, so a graph drawn from both was drawn from two subprocess runs against a working tree an
+     * operator is editing — its nodes could describe one state of the application and its edges the
+     * next, with nothing able to detect it. The `application-domain-model` behavior answers all four
+     * facts from a single import, which is the only shape in which "resources, their relationships and
+     * their module membership" is internally consistent.
+     *
+     * The two were kept for a while on the argument that a flat module list and a flat edge list
+     * answered two narrower questions this one did not. Both were then closed rather than argued: every
+     * per-edge field the relationships table carried — `isDisabled`, `accessScopeStrategy`,
+     * `parentResourceRequirement`, `primaryScope`, `allowCycle` — now rides in
+     * `Workbench_DomainResourceRelationship`, and `isDisabled` in particular was a defect while it was
+     * missing rather than a gap, because the graph drew a disabled edge exactly like a live one.
+     *
+     * One thing genuinely did NOT survive, and it is recorded here rather than in a commit message: a
+     * module registering ZERO resources produces no row, so it has no node. Wonder CRM's `engine`
+     * module is exactly that. The judgement was that a module contributing nothing to the DOMAIN has no
+     * place in a domain model, and that engine-scaffolding modules are what
+     * `workbenchSpecificationArtifacts` is for — not that the case was overlooked.
+     */
+    WorkbenchShared_ResourceType["DOMAIN_RESOURCES"] = "workbenchDomainResources";
+    /**
+     * Every application-specification family the journey produces that is NOT the application's own
+     * structure — the vision, the market, the requirements, the roadmap, the obligations — as one row
+     * each, carrying the artifact rendered for a human to read.
+     *
+     * ## Why the PRODUCT half needed its own resource
+     *
+     * The three siblings above all project the application's STRUCTURE: modules, edges, resources.
+     * None of them can carry a vision brief, because a vision brief is not a resource, an edge or a
+     * module — it is a prose document about the product the application is meant to be. Those
+     * documents were reachable only by opening a TypeScript file in an editor, which is not a product
+     * (issue #162).
+     *
+     * ## Why one resource rather than one per family
+     *
+     * The families are heterogeneous, and the two failure modes are symmetric: one destination per
+     * family risks a dozen half-built pages, one destination navigating all of them risks a
+     * lowest-common-denominator renderer. The answer taken is one destination whose rows are DERIVED
+     * from `APPLICATION_SPECIFICATION_SEMANTIC_SCHEMA_BINDINGS` — so the population cannot drift from
+     * the authority — grouped by the question each family answers, with an outline renderer as the
+     * floor and the artifacts already committed beside a family (`DIAGRAM.md`, `DECISIONS.md`)
+     * surfaced verbatim on top of it. The decision and its rejected alternatives are recorded on
+     * issue #162.
+     */
+    WorkbenchShared_ResourceType["SPECIFICATION_ARTIFACTS"] = "workbenchSpecificationArtifacts";
+    /*
+     * ── FAMILY ASPECT RESOURCES ──────────────────────────────────────────────────────────────────
+     *
+     * One resource per SECOND-LEVEL aspect of a specification family (the vision's success
+     * criteria, the market's ICPs, the roadmap's phases, …), so the product graph the snapshots
+     * flatten becomes navigable. Their canonical declaration — item schemas, business keys, edges —
+     * is `FAMILY_ASPECTS_REGISTRY` in `@wildo-ai/saas-specifications` (`_core/family-aspects.*`):
+     * this enum and the descriptor table beside it are the SPINE's schema-agnostic transcription,
+     * held to the registry by a companion-side parity test (the spine deliberately never imports
+     * saas-specifications).
+     *
+     * Same nature as their two siblings above: INTROSPECTION-backed, derived per read from the
+     * landed files, READ/LIST only. Their READ pages are NOT addressable — references open them as
+     * POPUPS (decided 2026-09-01); the artifacts resource stays the primary surface.
+     */
+    /*
+     * ── The CREATION PLANE (added 2026-09-01, `workbench-creation-board-resources.md` Phase 2) ──
+     *
+     * The four families below are NOT projections of the application's source: they are the
+     * COMPANION'S OWN RUNTIME projections for the one application it serves — the playbook
+     * eligibility board, the build-plan dispatch view, the run write-register and the execution
+     * traces. They ride the same INTROSPECTION adapter through the same port, but their behaviors
+     * materialize IN-PROCESS (no subprocess, no app-dist import), their binding declares the
+     * `APPLICATION_RUNTIME` tenancy stance, and their read variants are AUTHENTICATED (`APP_USER`) —
+     * the structural projections' `APP_PUBLIC` argument ("anyone with the working tree can already
+     * read this") does not extend to runtime state.
+     */
+    /**
+     * One row per compiled playbook, carrying its ELIGIBILITY VERDICT — can it run right now, and if
+     * not, why not — plus the overwrite/stale annotations a creator weighs before dispatching.
+     *
+     * The rows are a projection of `listPlaybookEligibility()`, the ~10s recompute the creation
+     * board's Playbooks pane renders; the companion serves them through a `{board, computedAt}` cache
+     * so resource-surface consumers (RMM, lists) do not multiply the recompute. `computedAt` and the
+     * derived journey `phase` are projected onto every row — board-level scalars become row fields,
+     * because a resource row must be complete on its own.
      */
-    WorkbenchShared_ResourceType["RESOURCE_RELATIONSHIPS"] = "workbenchResourceRelationships";
+    WorkbenchShared_ResourceType["PLAYBOOKS"] = "workbenchPlaybooks";
+    /**
+     * One row per build-plan task, in the DISPATCH view: its status (`ready` / `landed` / `blocked`),
+     * objective and target kind.
+     *
+     * DELIBERATELY THIN beside `ASPECT_BUILD_TASK` (`workbenchBuildTasks`), which projects the SAME
+     * authored population from the specification artifact with its traceability edges. The two answer
+     * different questions — the aspect answers "what did the journey author" (subprocess, from the
+     * artifact), this one answers "what can the dispatcher run next and what has landed" (in-process,
+     * computed against git by the dispatch service). Authored detail (skillRefs, serves edges) stays
+     * on the aspect row sharing the same `taskRef`; duplicating it here would be a second enumeration
+     * of the authored shape, one drift away from lying.
+     */
+    WorkbenchShared_ResourceType["BUILD_PLAN_TASKS"] = "workbenchBuildPlanTasks";
+    /**
+     * One row per playbook run's WRITE RECORD — which files it wrote, with `existedBefore` per file —
+     * the evidence lane that makes every dispatch on the creation board revertable. Pre-image BYTES
+     * are deliberately not projected (they belong to the revert mechanism, not to a list row).
+     */
+    WorkbenchShared_ResourceType["RUN_WRITE_RECORDS"] = "workbenchRunWriteRecords";
+    /**
+     * One row per execution-trace session — the session id, when it started, and how many events and
+     * steps it recorded. The detail (events, artifacts) stays on the companion's trace routes for
+     * now; this resource is the queryable index the board links from.
+     */
+    WorkbenchShared_ResourceType["TRACE_SESSIONS"] = "workbenchTraceSessions";
+    WorkbenchShared_ResourceType["ASPECT_VISION_IDEA"] = "workbenchVisionIdeas";
+    WorkbenchShared_ResourceType["ASPECT_VISION_PROBLEM"] = "workbenchVisionProblems";
+    WorkbenchShared_ResourceType["ASPECT_VISION_MISSION"] = "workbenchVisionMissions";
+    WorkbenchShared_ResourceType["ASPECT_VISION_SUCCESS_CRITERION"] = "workbenchVisionSuccessCriteria";
+    WorkbenchShared_ResourceType["ASPECT_VISION_CONSTRAINT"] = "workbenchVisionConstraints";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_CATEGORY"] = "workbenchMarketCategories";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_ICP"] = "workbenchMarketIcps";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_PERSONA"] = "workbenchMarketPersonas";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_JOB"] = "workbenchMarketJobs";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_PAIN"] = "workbenchMarketPains";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_GAIN"] = "workbenchMarketGains";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_TONE_OF_VOICE"] = "workbenchMarketTonesOfVoice";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_BENEFIT"] = "workbenchMarketBenefits";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_POSITIONING"] = "workbenchMarketPositionings";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_CHANNEL"] = "workbenchMarketChannels";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_ALTERNATIVE"] = "workbenchMarketAlternatives";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_TRIGGER"] = "workbenchMarketTriggers";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_BUYING_JOURNEY"] = "workbenchMarketBuyingJourneys";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_PROOF"] = "workbenchMarketProofs";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_OBJECTION"] = "workbenchMarketObjections";
+    WorkbenchShared_ResourceType["ASPECT_MARKET_MESSAGE_TEMPLATE"] = "workbenchMarketMessageTemplates";
+    WorkbenchShared_ResourceType["ASPECT_REQUIREMENT_FUNCTIONAL"] = "workbenchFunctionalRequirements";
+    WorkbenchShared_ResourceType["ASPECT_REQUIREMENT_NON_FUNCTIONAL"] = "workbenchNonFunctionalRequirements";
+    WorkbenchShared_ResourceType["ASPECT_FEATURE_DRAFT"] = "workbenchFeatureDrafts";
+    WorkbenchShared_ResourceType["ASPECT_ROADMAP_PHASE"] = "workbenchRoadmapPhases";
+    WorkbenchShared_ResourceType["ASPECT_PRICING_PLAN"] = "workbenchPricingPlans";
+    WorkbenchShared_ResourceType["ASPECT_BRAND_NAME"] = "workbenchBrandNames";
+    WorkbenchShared_ResourceType["ASPECT_BRAND_LOGO_DIRECTION"] = "workbenchBrandLogoDirections";
+    WorkbenchShared_ResourceType["ASPECT_BRAND_VISUAL_TONE"] = "workbenchBrandVisualTones";
+    WorkbenchShared_ResourceType["ASPECT_BRAND_ASSET"] = "workbenchBrandAssets";
+    WorkbenchShared_ResourceType["ASPECT_DOMAIN_PLAN_MODULE"] = "workbenchDomainPlanModules";
+    WorkbenchShared_ResourceType["ASPECT_DOMAIN_PLAN_RELATIONSHIP"] = "workbenchDomainPlanRelationships";
+    WorkbenchShared_ResourceType["ASPECT_BUILD_TASK"] = "workbenchBuildTasks";
+    WorkbenchShared_ResourceType["ASPECT_PLACEMENT_GROUP"] = "workbenchPlacementGroups";
+    WorkbenchShared_ResourceType["ASPECT_PLACEMENT_DECISION"] = "workbenchPlacementDecisions";
+    WorkbenchShared_ResourceType["ASPECT_COMPLIANCE_CANDIDATE_SECTION"] = "workbenchComplianceCandidateSections";
+    WorkbenchShared_ResourceType["ASPECT_COMPLIANCE_CANDIDATE_VARIANT_SELECTION"] = "workbenchComplianceCandidateVariantSelections";
+    WorkbenchShared_ResourceType["ASPECT_DOCUMENT_FACT_DECLARATION"] = "workbenchDocumentFactDeclarations";
+    WorkbenchShared_ResourceType["ASPECT_AUTHORED_DOCUMENT_FACT_DECLARATION"] = "workbenchAuthoredDocumentFactDeclarations";
+    WorkbenchShared_ResourceType["ASPECT_PROCESSOR_REGISTER_ENTRY"] = "workbenchProcessorRegisterEntries";
+    WorkbenchShared_ResourceType["ASPECT_RELEASE_POLICY_SELECTION"] = "workbenchReleasePolicySelections";
+    WorkbenchShared_ResourceType["ASPECT_DOCUMENT_PUBLICATION_VARIANT"] = "workbenchDocumentPublicationVariants";
 })(WorkbenchShared_ResourceType || (WorkbenchShared_ResourceType = {}));
 /**
  * The field each resource is ADDRESSED BY — and it must be a field the rows actually carry.
  *
- * `workbenchApplicationModules` is identified by `moduleId`, not by a composed
- * `workbenchApplicationModuleId`. The convention-shaped name was declared here first and no row ever
- * carried it: the schema marks `moduleId` as the primary key, the behavior emits `moduleId`, and
- * `identityFields: ['moduleId']` composes the id from it. Nothing anywhere produced the other name,
- * so every consumer that addresses a row THROUGH this map looked for a field that did not exist.
- *
- * READ still worked, which is what kept it hidden: the adapter filters by `identityFields`, so
- * `GET …/workbench-application-modules/engine` answered 200 while the frontend list refused every
- * row click with "could not resolve resource id from list item" — the id it was told to read was
- * absent from the item.
- *
- * Its sibling is the contrast that settles the rule rather than an inconsistency: an edge has no
- * natural key, so `workbenchResourceRelationshipId` is SYNTHESIZED from three fields and is a real
- * declared field of the schema, present on every row. Both entries now name something real; one
- * happens to be the source's own key and the other is composed.
+ * ## The rule, and the defect that produced it
+ *
+ * A convention-shaped name declared here that no row carries makes every consumer addressing a row
+ * THROUGH this map look for a field that does not exist. The resource this was measured on
+ * (`workbenchApplicationModules`, removed 2026-08-31) declared `workbenchApplicationModuleId` while
+ * its schema, its behavior and its `identityFields` all said `moduleId`.
+ *
+ * READ still worked, which is what kept it hidden: the adapter filters by `identityFields`, so the
+ * addressed route answered 200 while the frontend list refused every row click with "could not
+ * resolve resource id from list item" — the id it was told to read was absent from the item. A green
+ * addressed READ is therefore NOT evidence that this map is right; the list row click is.
+ *
+ * So an entry here is either the source's OWN key, or a name COMPOSED by `identityFields` and
+ * declared as a real field of the schema. Never a name that merely follows the convention.
  */
 export const WorkbenchShared_ResourceFieldIdentifier = {
-    [WorkbenchShared_ResourceType.APPLICATION_MODULES]: 'moduleId',
-    [WorkbenchShared_ResourceType.RESOURCE_RELATIONSHIPS]: 'workbenchResourceRelationshipId',
+    /*
+     * COMPOSED from `resourceType`, following the relationships sibling rather than the modules one.
+     *
+     * The behavior's rows do carry `resourceType`, so the source's own key could have been used
+     * directly — as `moduleId` is. It is composed instead because `resourceType` is a name the FIELD
+     * IDENTIFIER MAP would then publish globally: that map is merged with the engine's and consumed by
+     * `buildFieldIdentifierToResourceTypeMap`, which resolves a foreign-key field NAME to the resource
+     * it points at. A generic identifier there is a name any application could collide with, on a map
+     * whose whole job is that names are unambiguous.
+     */
+    [WorkbenchShared_ResourceType.DOMAIN_RESOURCES]: 'workbenchDomainResourceId',
+    /*
+     * The FAMILY id, which is the source's own key — the `moduleId` case rather than the composed one.
+     *
+     * A family id (`vision-brief`, `compliance-program`) is unique by construction: the semantic
+     * authority is a map keyed by it. And unlike `resourceType`, it is not a name any application's
+     * foreign-key field could collide with on the global field-identifier map, so there is nothing for
+     * a composed name to protect against here.
+     */
+    [WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS]: 'family',
+    /*
+     * Aspect identifiers are all COMPOSED (`workbenchMarketIcpId`), for the same reason as
+     * DOMAIN_RESOURCES: the raw business-key field is `ref` on most aspects — a name applications
+     * collide with constantly — and this map publishes globally. The projection emits the composed
+     * field on every row (value = the business key, the aspect key for singletons, or the indexed
+     * fallback), so the "a name the rows actually carry" rule above holds.
+     */
+    /*
+     * The creation-plane identifiers are all COMPOSED (`workbenchPlaybookId` from `playbookRef`, …):
+     * the raw business keys (`playbookRef`, `taskRef`, `runId`, `sessionId`) are names an
+     * application's own foreign-key fields could collide with on the global field-identifier map,
+     * which is the same reason DOMAIN_RESOURCES composes. Unlike DOMAIN_RESOURCES the field is
+     * EMITTED BY THE BEHAVIOR rather than composed by `identityFields` — composition refuses any
+     * value outside `[a-zA-Z0-9_-]`, and playbook refs (`top_down.phase-gate`) and trace session ids
+     * legitimately carry dots — so the projection service sanitizes and duplicate-checks. The "a name
+     * the rows actually carry" rule holds either way.
+     */
+    [WorkbenchShared_ResourceType.PLAYBOOKS]: 'workbenchPlaybookId',
+    [WorkbenchShared_ResourceType.BUILD_PLAN_TASKS]: 'workbenchBuildPlanTaskId',
+    [WorkbenchShared_ResourceType.RUN_WRITE_RECORDS]: 'workbenchRunWriteRecordId',
+    [WorkbenchShared_ResourceType.TRACE_SESSIONS]: 'workbenchTraceSessionId',
+    [WorkbenchShared_ResourceType.ASPECT_VISION_IDEA]: 'workbenchVisionIdeaId',
+    [WorkbenchShared_ResourceType.ASPECT_VISION_PROBLEM]: 'workbenchVisionProblemId',
+    [WorkbenchShared_ResourceType.ASPECT_VISION_MISSION]: 'workbenchVisionMissionId',
+    [WorkbenchShared_ResourceType.ASPECT_VISION_SUCCESS_CRITERION]: 'workbenchVisionSuccessCriterionId',
+    [WorkbenchShared_ResourceType.ASPECT_VISION_CONSTRAINT]: 'workbenchVisionConstraintId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_CATEGORY]: 'workbenchMarketCategoryId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_ICP]: 'workbenchMarketIcpId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_PERSONA]: 'workbenchMarketPersonaId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_JOB]: 'workbenchMarketJobId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_PAIN]: 'workbenchMarketPainId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_GAIN]: 'workbenchMarketGainId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_TONE_OF_VOICE]: 'workbenchMarketToneOfVoiceId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_BENEFIT]: 'workbenchMarketBenefitId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_POSITIONING]: 'workbenchMarketPositioningId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_CHANNEL]: 'workbenchMarketChannelId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_ALTERNATIVE]: 'workbenchMarketAlternativeId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_TRIGGER]: 'workbenchMarketTriggerId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_BUYING_JOURNEY]: 'workbenchMarketBuyingJourneyId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_PROOF]: 'workbenchMarketProofId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_OBJECTION]: 'workbenchMarketObjectionId',
+    [WorkbenchShared_ResourceType.ASPECT_MARKET_MESSAGE_TEMPLATE]: 'workbenchMarketMessageTemplateId',
+    [WorkbenchShared_ResourceType.ASPECT_REQUIREMENT_FUNCTIONAL]: 'workbenchFunctionalRequirementId',
+    [WorkbenchShared_ResourceType.ASPECT_REQUIREMENT_NON_FUNCTIONAL]: 'workbenchNonFunctionalRequirementId',
+    [WorkbenchShared_ResourceType.ASPECT_FEATURE_DRAFT]: 'workbenchFeatureDraftId',
+    [WorkbenchShared_ResourceType.ASPECT_ROADMAP_PHASE]: 'workbenchRoadmapPhaseId',
+    [WorkbenchShared_ResourceType.ASPECT_PRICING_PLAN]: 'workbenchPricingPlanId',
+    [WorkbenchShared_ResourceType.ASPECT_BRAND_NAME]: 'workbenchBrandNameId',
+    [WorkbenchShared_ResourceType.ASPECT_BRAND_LOGO_DIRECTION]: 'workbenchBrandLogoDirectionId',
+    [WorkbenchShared_ResourceType.ASPECT_BRAND_VISUAL_TONE]: 'workbenchBrandVisualToneId',
+    [WorkbenchShared_ResourceType.ASPECT_BRAND_ASSET]: 'workbenchBrandAssetId',
+    [WorkbenchShared_ResourceType.ASPECT_DOMAIN_PLAN_MODULE]: 'workbenchDomainPlanModuleId',
+    [WorkbenchShared_ResourceType.ASPECT_DOMAIN_PLAN_RELATIONSHIP]: 'workbenchDomainPlanRelationshipId',
+    [WorkbenchShared_ResourceType.ASPECT_BUILD_TASK]: 'workbenchBuildTaskId',
+    [WorkbenchShared_ResourceType.ASPECT_PLACEMENT_GROUP]: 'workbenchPlacementGroupId',
+    [WorkbenchShared_ResourceType.ASPECT_PLACEMENT_DECISION]: 'workbenchPlacementDecisionId',
+    [WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_CANDIDATE_SECTION]: 'workbenchComplianceCandidateSectionId',
+    [WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_CANDIDATE_VARIANT_SELECTION]: 'workbenchComplianceCandidateVariantSelectionId',
+    [WorkbenchShared_ResourceType.ASPECT_DOCUMENT_FACT_DECLARATION]: 'workbenchDocumentFactDeclarationId',
+    [WorkbenchShared_ResourceType.ASPECT_AUTHORED_DOCUMENT_FACT_DECLARATION]: 'workbenchAuthoredDocumentFactDeclarationId',
+    [WorkbenchShared_ResourceType.ASPECT_PROCESSOR_REGISTER_ENTRY]: 'workbenchProcessorRegisterEntryId',
+    [WorkbenchShared_ResourceType.ASPECT_RELEASE_POLICY_SELECTION]: 'workbenchReleasePolicySelectionId',
+    [WorkbenchShared_ResourceType.ASPECT_DOCUMENT_PUBLICATION_VARIANT]: 'workbenchDocumentPublicationVariantId',
 };
 /**
  * The frontend-service name the application-creation workbench identifies itself by.

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

@@ -1 +1 @@
-{"version":3,"file":"workbench-resources-types.custom.shared.schemas.js","sourceRoot":"","sources":["../../../../src/workbench/workbench-resources-types.custom.shared.schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,CAAN,IAAY,4BAUX;AAVD,WAAY,4BAA4B;IACtC,mFAAmD,CAAA;IACnD;;;;;;OAMG;IACH,yFAAyD,CAAA;AAC3D,CAAC,EAVW,4BAA4B,KAA5B,4BAA4B,QAUvC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,uCAAuC,GAAsD;IACxG,CAAC,4BAA4B,CAAC,mBAAmB,CAAC,EAAE,UAAU;IAC9D,CAAC,4BAA4B,CAAC,sBAAsB,CAAC,EAAE,iCAAiC;CACzF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,gCAAgC,CAAC","sourcesContent":["/**\n * The workbench's own resource vocabulary.\n *\n * A SEPARATE enum and factory map from `CustomShared_ResourceType`, deliberately. That map has six\n * consumers, two of which must not receive these: `platform-apps-manager` (which would register\n * resources it has no use for, and whose INIT lifecycle applies migrations) and the companion's i18n\n * labelling planner, which enumerates `Object.keys(...)` and would generate labels for them.\n *\n * These resources are INTROSPECTION-backed: nothing is stored, nothing is migrated, and only the\n * companion can serve them.\n */\nexport enum WorkbenchShared_ResourceType {\n  APPLICATION_MODULES = 'workbenchApplicationModules',\n  /**\n   * Every relationship edge the application's resources declare — how its domain is wired.\n   *\n   * Projected from a DIFFERENT behavior (`resources-registry`) than the modules beside it, which is\n   * what makes it the surface that proves the adapter generalizes: one binding shape, two behaviors,\n   * two row shapes, no adapter change.\n   */\n  RESOURCE_RELATIONSHIPS = 'workbenchResourceRelationships',\n}\n\n/**\n * The field each resource is ADDRESSED BY — and it must be a field the rows actually carry.\n *\n * `workbenchApplicationModules` is identified by `moduleId`, not by a composed\n * `workbenchApplicationModuleId`. The convention-shaped name was declared here first and no row ever\n * carried it: the schema marks `moduleId` as the primary key, the behavior emits `moduleId`, and\n * `identityFields: ['moduleId']` composes the id from it. Nothing anywhere produced the other name,\n * so every consumer that addresses a row THROUGH this map looked for a field that did not exist.\n *\n * READ still worked, which is what kept it hidden: the adapter filters by `identityFields`, so\n * `GET …/workbench-application-modules/engine` answered 200 while the frontend list refused every\n * row click with \"could not resolve resource id from list item\" — the id it was told to read was\n * absent from the item.\n *\n * Its sibling is the contrast that settles the rule rather than an inconsistency: an edge has no\n * natural key, so `workbenchResourceRelationshipId` is SYNTHESIZED from three fields and is a real\n * declared field of the schema, present on every row. Both entries now name something real; one\n * happens to be the source's own key and the other is composed.\n */\nexport const WorkbenchShared_ResourceFieldIdentifier: { [key in WorkbenchShared_ResourceType]: string } = {\n  [WorkbenchShared_ResourceType.APPLICATION_MODULES]: 'moduleId',\n  [WorkbenchShared_ResourceType.RESOURCE_RELATIONSHIPS]: 'workbenchResourceRelationshipId',\n};\n\n/**\n * The frontend-service name the application-creation workbench identifies itself by.\n *\n * Shared because BOTH sides must agree and neither owns it alone: the workbench sends it as\n * `VITE_FRONTEND_SERVICE_NAME` on every `/application-config` and `/i18n/labels` request, and the\n * companion seeds an entry under exactly this key so the engine's `ApplicationConfigController` can\n * answer instead of refusing with `app_configuration_unknown_frontend_service`.\n *\n * Two string literals in two packages would compile perfectly and fail at runtime with an error that\n * names neither of them.\n */\nexport const WORKBENCH_FRONTEND_SERVICE_NAME = 'application-creation-workbench';\n"]}
+{"version":3,"file":"workbench-resources-types.custom.shared.schemas.js","sourceRoot":"","sources":["../../../../src/workbench/workbench-resources-types.custom.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The workbench's own resource vocabulary.\n *\n * A SEPARATE enum and factory map from `CustomShared_ResourceType`, deliberately. That map has six\n * consumers, two of which must not receive these: `platform-apps-manager` (which would register\n * resources it has no use for, and whose INIT lifecycle applies migrations) and the companion's i18n\n * labelling planner, which enumerates `Object.keys(...)` and would generate labels for them.\n *\n * These resources are INTROSPECTION-backed: nothing is stored, nothing is migrated, and only the\n * companion can serve them.\n */\nexport enum WorkbenchShared_ResourceType {\n  /**\n   * The application's domain model as ONE row per resource — module membership, specification prose\n   * and the relationships that resource participates in, all in the same row.\n   *\n   * ## Why ONE resource rather than a module list beside an edge list\n   *\n   * It replaced exactly that, on 2026-08-31. `workbenchApplicationModules` and\n   * `workbenchResourceRelationships` were projections of DIFFERENT companion behaviors on DIFFERENT\n   * targets, so a graph drawn from both was drawn from two subprocess runs against a working tree an\n   * operator is editing — its nodes could describe one state of the application and its edges the\n   * next, with nothing able to detect it. The `application-domain-model` behavior answers all four\n   * facts from a single import, which is the only shape in which \"resources, their relationships and\n   * their module membership\" is internally consistent.\n   *\n   * The two were kept for a while on the argument that a flat module list and a flat edge list\n   * answered two narrower questions this one did not. Both were then closed rather than argued: every\n   * per-edge field the relationships table carried — `isDisabled`, `accessScopeStrategy`,\n   * `parentResourceRequirement`, `primaryScope`, `allowCycle` — now rides in\n   * `Workbench_DomainResourceRelationship`, and `isDisabled` in particular was a defect while it was\n   * missing rather than a gap, because the graph drew a disabled edge exactly like a live one.\n   *\n   * One thing genuinely did NOT survive, and it is recorded here rather than in a commit message: a\n   * module registering ZERO resources produces no row, so it has no node. Wonder CRM's `engine`\n   * module is exactly that. The judgement was that a module contributing nothing to the DOMAIN has no\n   * place in a domain model, and that engine-scaffolding modules are what\n   * `workbenchSpecificationArtifacts` is for — not that the case was overlooked.\n   */\n  DOMAIN_RESOURCES = 'workbenchDomainResources',\n  /**\n   * Every application-specification family the journey produces that is NOT the application's own\n   * structure — the vision, the market, the requirements, the roadmap, the obligations — as one row\n   * each, carrying the artifact rendered for a human to read.\n   *\n   * ## Why the PRODUCT half needed its own resource\n   *\n   * The three siblings above all project the application's STRUCTURE: modules, edges, resources.\n   * None of them can carry a vision brief, because a vision brief is not a resource, an edge or a\n   * module — it is a prose document about the product the application is meant to be. Those\n   * documents were reachable only by opening a TypeScript file in an editor, which is not a product\n   * (issue #162).\n   *\n   * ## Why one resource rather than one per family\n   *\n   * The families are heterogeneous, and the two failure modes are symmetric: one destination per\n   * family risks a dozen half-built pages, one destination navigating all of them risks a\n   * lowest-common-denominator renderer. The answer taken is one destination whose rows are DERIVED\n   * from `APPLICATION_SPECIFICATION_SEMANTIC_SCHEMA_BINDINGS` — so the population cannot drift from\n   * the authority — grouped by the question each family answers, with an outline renderer as the\n   * floor and the artifacts already committed beside a family (`DIAGRAM.md`, `DECISIONS.md`)\n   * surfaced verbatim on top of it. The decision and its rejected alternatives are recorded on\n   * issue #162.\n   */\n  SPECIFICATION_ARTIFACTS = 'workbenchSpecificationArtifacts',\n\n  /*\n   * ── FAMILY ASPECT RESOURCES ──────────────────────────────────────────────────────────────────\n   *\n   * One resource per SECOND-LEVEL aspect of a specification family (the vision's success\n   * criteria, the market's ICPs, the roadmap's phases, …), so the product graph the snapshots\n   * flatten becomes navigable. Their canonical declaration — item schemas, business keys, edges —\n   * is `FAMILY_ASPECTS_REGISTRY` in `@wildo-ai/saas-specifications` (`_core/family-aspects.*`):\n   * this enum and the descriptor table beside it are the SPINE's schema-agnostic transcription,\n   * held to the registry by a companion-side parity test (the spine deliberately never imports\n   * saas-specifications).\n   *\n   * Same nature as their two siblings above: INTROSPECTION-backed, derived per read from the\n   * landed files, READ/LIST only. Their READ pages are NOT addressable — references open them as\n   * POPUPS (decided 2026-09-01); the artifacts resource stays the primary surface.\n   */\n  /*\n   * ── The CREATION PLANE (added 2026-09-01, `workbench-creation-board-resources.md` Phase 2) ──\n   *\n   * The four families below are NOT projections of the application's source: they are the\n   * COMPANION'S OWN RUNTIME projections for the one application it serves — the playbook\n   * eligibility board, the build-plan dispatch view, the run write-register and the execution\n   * traces. They ride the same INTROSPECTION adapter through the same port, but their behaviors\n   * materialize IN-PROCESS (no subprocess, no app-dist import), their binding declares the\n   * `APPLICATION_RUNTIME` tenancy stance, and their read variants are AUTHENTICATED (`APP_USER`) —\n   * the structural projections' `APP_PUBLIC` argument (\"anyone with the working tree can already\n   * read this\") does not extend to runtime state.\n   */\n  /**\n   * One row per compiled playbook, carrying its ELIGIBILITY VERDICT — can it run right now, and if\n   * not, why not — plus the overwrite/stale annotations a creator weighs before dispatching.\n   *\n   * The rows are a projection of `listPlaybookEligibility()`, the ~10s recompute the creation\n   * board's Playbooks pane renders; the companion serves them through a `{board, computedAt}` cache\n   * so resource-surface consumers (RMM, lists) do not multiply the recompute. `computedAt` and the\n   * derived journey `phase` are projected onto every row — board-level scalars become row fields,\n   * because a resource row must be complete on its own.\n   */\n  PLAYBOOKS = 'workbenchPlaybooks',\n  /**\n   * One row per build-plan task, in the DISPATCH view: its status (`ready` / `landed` / `blocked`),\n   * objective and target kind.\n   *\n   * DELIBERATELY THIN beside `ASPECT_BUILD_TASK` (`workbenchBuildTasks`), which projects the SAME\n   * authored population from the specification artifact with its traceability edges. The two answer\n   * different questions — the aspect answers \"what did the journey author\" (subprocess, from the\n   * artifact), this one answers \"what can the dispatcher run next and what has landed\" (in-process,\n   * computed against git by the dispatch service). Authored detail (skillRefs, serves edges) stays\n   * on the aspect row sharing the same `taskRef`; duplicating it here would be a second enumeration\n   * of the authored shape, one drift away from lying.\n   */\n  BUILD_PLAN_TASKS = 'workbenchBuildPlanTasks',\n  /**\n   * One row per playbook run's WRITE RECORD — which files it wrote, with `existedBefore` per file —\n   * the evidence lane that makes every dispatch on the creation board revertable. Pre-image BYTES\n   * are deliberately not projected (they belong to the revert mechanism, not to a list row).\n   */\n  RUN_WRITE_RECORDS = 'workbenchRunWriteRecords',\n  /**\n   * One row per execution-trace session — the session id, when it started, and how many events and\n   * steps it recorded. The detail (events, artifacts) stays on the companion's trace routes for\n   * now; this resource is the queryable index the board links from.\n   */\n  TRACE_SESSIONS = 'workbenchTraceSessions',\n  ASPECT_VISION_IDEA = 'workbenchVisionIdeas',\n  ASPECT_VISION_PROBLEM = 'workbenchVisionProblems',\n  ASPECT_VISION_MISSION = 'workbenchVisionMissions',\n  ASPECT_VISION_SUCCESS_CRITERION = 'workbenchVisionSuccessCriteria',\n  ASPECT_VISION_CONSTRAINT = 'workbenchVisionConstraints',\n  ASPECT_MARKET_CATEGORY = 'workbenchMarketCategories',\n  ASPECT_MARKET_ICP = 'workbenchMarketIcps',\n  ASPECT_MARKET_PERSONA = 'workbenchMarketPersonas',\n  ASPECT_MARKET_JOB = 'workbenchMarketJobs',\n  ASPECT_MARKET_PAIN = 'workbenchMarketPains',\n  ASPECT_MARKET_GAIN = 'workbenchMarketGains',\n  ASPECT_MARKET_TONE_OF_VOICE = 'workbenchMarketTonesOfVoice',\n  ASPECT_MARKET_BENEFIT = 'workbenchMarketBenefits',\n  ASPECT_MARKET_POSITIONING = 'workbenchMarketPositionings',\n  ASPECT_MARKET_CHANNEL = 'workbenchMarketChannels',\n  ASPECT_MARKET_ALTERNATIVE = 'workbenchMarketAlternatives',\n  ASPECT_MARKET_TRIGGER = 'workbenchMarketTriggers',\n  ASPECT_MARKET_BUYING_JOURNEY = 'workbenchMarketBuyingJourneys',\n  ASPECT_MARKET_PROOF = 'workbenchMarketProofs',\n  ASPECT_MARKET_OBJECTION = 'workbenchMarketObjections',\n  ASPECT_MARKET_MESSAGE_TEMPLATE = 'workbenchMarketMessageTemplates',\n  ASPECT_REQUIREMENT_FUNCTIONAL = 'workbenchFunctionalRequirements',\n  ASPECT_REQUIREMENT_NON_FUNCTIONAL = 'workbenchNonFunctionalRequirements',\n  ASPECT_FEATURE_DRAFT = 'workbenchFeatureDrafts',\n  ASPECT_ROADMAP_PHASE = 'workbenchRoadmapPhases',\n  ASPECT_PRICING_PLAN = 'workbenchPricingPlans',\n  ASPECT_BRAND_NAME = 'workbenchBrandNames',\n  ASPECT_BRAND_LOGO_DIRECTION = 'workbenchBrandLogoDirections',\n  ASPECT_BRAND_VISUAL_TONE = 'workbenchBrandVisualTones',\n  ASPECT_BRAND_ASSET = 'workbenchBrandAssets',\n  ASPECT_DOMAIN_PLAN_MODULE = 'workbenchDomainPlanModules',\n  ASPECT_DOMAIN_PLAN_RELATIONSHIP = 'workbenchDomainPlanRelationships',\n  ASPECT_BUILD_TASK = 'workbenchBuildTasks',\n  ASPECT_PLACEMENT_GROUP = 'workbenchPlacementGroups',\n  ASPECT_PLACEMENT_DECISION = 'workbenchPlacementDecisions',\n  ASPECT_COMPLIANCE_CANDIDATE_SECTION = 'workbenchComplianceCandidateSections',\n  ASPECT_COMPLIANCE_CANDIDATE_VARIANT_SELECTION = 'workbenchComplianceCandidateVariantSelections',\n  ASPECT_DOCUMENT_FACT_DECLARATION = 'workbenchDocumentFactDeclarations',\n  ASPECT_AUTHORED_DOCUMENT_FACT_DECLARATION = 'workbenchAuthoredDocumentFactDeclarations',\n  ASPECT_PROCESSOR_REGISTER_ENTRY = 'workbenchProcessorRegisterEntries',\n  ASPECT_RELEASE_POLICY_SELECTION = 'workbenchReleasePolicySelections',\n  ASPECT_DOCUMENT_PUBLICATION_VARIANT = 'workbenchDocumentPublicationVariants',\n}\n\n/**\n * The field each resource is ADDRESSED BY — and it must be a field the rows actually carry.\n *\n * ## The rule, and the defect that produced it\n *\n * A convention-shaped name declared here that no row carries makes every consumer addressing a row\n * THROUGH this map look for a field that does not exist. The resource this was measured on\n * (`workbenchApplicationModules`, removed 2026-08-31) declared `workbenchApplicationModuleId` while\n * its schema, its behavior and its `identityFields` all said `moduleId`.\n *\n * READ still worked, which is what kept it hidden: the adapter filters by `identityFields`, so the\n * addressed route answered 200 while the frontend list refused every row click with \"could not\n * resolve resource id from list item\" — the id it was told to read was absent from the item. A green\n * addressed READ is therefore NOT evidence that this map is right; the list row click is.\n *\n * So an entry here is either the source's OWN key, or a name COMPOSED by `identityFields` and\n * declared as a real field of the schema. Never a name that merely follows the convention.\n */\nexport const WorkbenchShared_ResourceFieldIdentifier: { [key in WorkbenchShared_ResourceType]: string } = {\n  /*\n   * COMPOSED from `resourceType`, following the relationships sibling rather than the modules one.\n   *\n   * The behavior's rows do carry `resourceType`, so the source's own key could have been used\n   * directly — as `moduleId` is. It is composed instead because `resourceType` is a name the FIELD\n   * IDENTIFIER MAP would then publish globally: that map is merged with the engine's and consumed by\n   * `buildFieldIdentifierToResourceTypeMap`, which resolves a foreign-key field NAME to the resource\n   * it points at. A generic identifier there is a name any application could collide with, on a map\n   * whose whole job is that names are unambiguous.\n   */\n  [WorkbenchShared_ResourceType.DOMAIN_RESOURCES]: 'workbenchDomainResourceId',\n  /*\n   * The FAMILY id, which is the source's own key — the `moduleId` case rather than the composed one.\n   *\n   * A family id (`vision-brief`, `compliance-program`) is unique by construction: the semantic\n   * authority is a map keyed by it. And unlike `resourceType`, it is not a name any application's\n   * foreign-key field could collide with on the global field-identifier map, so there is nothing for\n   * a composed name to protect against here.\n   */\n  [WorkbenchShared_ResourceType.SPECIFICATION_ARTIFACTS]: 'family',\n  /*\n   * Aspect identifiers are all COMPOSED (`workbenchMarketIcpId`), for the same reason as\n   * DOMAIN_RESOURCES: the raw business-key field is `ref` on most aspects — a name applications\n   * collide with constantly — and this map publishes globally. The projection emits the composed\n   * field on every row (value = the business key, the aspect key for singletons, or the indexed\n   * fallback), so the \"a name the rows actually carry\" rule above holds.\n   */\n  /*\n   * The creation-plane identifiers are all COMPOSED (`workbenchPlaybookId` from `playbookRef`, …):\n   * the raw business keys (`playbookRef`, `taskRef`, `runId`, `sessionId`) are names an\n   * application's own foreign-key fields could collide with on the global field-identifier map,\n   * which is the same reason DOMAIN_RESOURCES composes. Unlike DOMAIN_RESOURCES the field is\n   * EMITTED BY THE BEHAVIOR rather than composed by `identityFields` — composition refuses any\n   * value outside `[a-zA-Z0-9_-]`, and playbook refs (`top_down.phase-gate`) and trace session ids\n   * legitimately carry dots — so the projection service sanitizes and duplicate-checks. The \"a name\n   * the rows actually carry\" rule holds either way.\n   */\n  [WorkbenchShared_ResourceType.PLAYBOOKS]: 'workbenchPlaybookId',\n  [WorkbenchShared_ResourceType.BUILD_PLAN_TASKS]: 'workbenchBuildPlanTaskId',\n  [WorkbenchShared_ResourceType.RUN_WRITE_RECORDS]: 'workbenchRunWriteRecordId',\n  [WorkbenchShared_ResourceType.TRACE_SESSIONS]: 'workbenchTraceSessionId',\n  [WorkbenchShared_ResourceType.ASPECT_VISION_IDEA]: 'workbenchVisionIdeaId',\n  [WorkbenchShared_ResourceType.ASPECT_VISION_PROBLEM]: 'workbenchVisionProblemId',\n  [WorkbenchShared_ResourceType.ASPECT_VISION_MISSION]: 'workbenchVisionMissionId',\n  [WorkbenchShared_ResourceType.ASPECT_VISION_SUCCESS_CRITERION]: 'workbenchVisionSuccessCriterionId',\n  [WorkbenchShared_ResourceType.ASPECT_VISION_CONSTRAINT]: 'workbenchVisionConstraintId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_CATEGORY]: 'workbenchMarketCategoryId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_ICP]: 'workbenchMarketIcpId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_PERSONA]: 'workbenchMarketPersonaId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_JOB]: 'workbenchMarketJobId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_PAIN]: 'workbenchMarketPainId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_GAIN]: 'workbenchMarketGainId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_TONE_OF_VOICE]: 'workbenchMarketToneOfVoiceId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_BENEFIT]: 'workbenchMarketBenefitId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_POSITIONING]: 'workbenchMarketPositioningId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_CHANNEL]: 'workbenchMarketChannelId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_ALTERNATIVE]: 'workbenchMarketAlternativeId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_TRIGGER]: 'workbenchMarketTriggerId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_BUYING_JOURNEY]: 'workbenchMarketBuyingJourneyId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_PROOF]: 'workbenchMarketProofId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_OBJECTION]: 'workbenchMarketObjectionId',\n  [WorkbenchShared_ResourceType.ASPECT_MARKET_MESSAGE_TEMPLATE]: 'workbenchMarketMessageTemplateId',\n  [WorkbenchShared_ResourceType.ASPECT_REQUIREMENT_FUNCTIONAL]: 'workbenchFunctionalRequirementId',\n  [WorkbenchShared_ResourceType.ASPECT_REQUIREMENT_NON_FUNCTIONAL]: 'workbenchNonFunctionalRequirementId',\n  [WorkbenchShared_ResourceType.ASPECT_FEATURE_DRAFT]: 'workbenchFeatureDraftId',\n  [WorkbenchShared_ResourceType.ASPECT_ROADMAP_PHASE]: 'workbenchRoadmapPhaseId',\n  [WorkbenchShared_ResourceType.ASPECT_PRICING_PLAN]: 'workbenchPricingPlanId',\n  [WorkbenchShared_ResourceType.ASPECT_BRAND_NAME]: 'workbenchBrandNameId',\n  [WorkbenchShared_ResourceType.ASPECT_BRAND_LOGO_DIRECTION]: 'workbenchBrandLogoDirectionId',\n  [WorkbenchShared_ResourceType.ASPECT_BRAND_VISUAL_TONE]: 'workbenchBrandVisualToneId',\n  [WorkbenchShared_ResourceType.ASPECT_BRAND_ASSET]: 'workbenchBrandAssetId',\n  [WorkbenchShared_ResourceType.ASPECT_DOMAIN_PLAN_MODULE]: 'workbenchDomainPlanModuleId',\n  [WorkbenchShared_ResourceType.ASPECT_DOMAIN_PLAN_RELATIONSHIP]: 'workbenchDomainPlanRelationshipId',\n  [WorkbenchShared_ResourceType.ASPECT_BUILD_TASK]: 'workbenchBuildTaskId',\n  [WorkbenchShared_ResourceType.ASPECT_PLACEMENT_GROUP]: 'workbenchPlacementGroupId',\n  [WorkbenchShared_ResourceType.ASPECT_PLACEMENT_DECISION]: 'workbenchPlacementDecisionId',\n  [WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_CANDIDATE_SECTION]: 'workbenchComplianceCandidateSectionId',\n  [WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_CANDIDATE_VARIANT_SELECTION]: 'workbenchComplianceCandidateVariantSelectionId',\n  [WorkbenchShared_ResourceType.ASPECT_DOCUMENT_FACT_DECLARATION]: 'workbenchDocumentFactDeclarationId',\n  [WorkbenchShared_ResourceType.ASPECT_AUTHORED_DOCUMENT_FACT_DECLARATION]: 'workbenchAuthoredDocumentFactDeclarationId',\n  [WorkbenchShared_ResourceType.ASPECT_PROCESSOR_REGISTER_ENTRY]: 'workbenchProcessorRegisterEntryId',\n  [WorkbenchShared_ResourceType.ASPECT_RELEASE_POLICY_SELECTION]: 'workbenchReleasePolicySelectionId',\n  [WorkbenchShared_ResourceType.ASPECT_DOCUMENT_PUBLICATION_VARIANT]: 'workbenchDocumentPublicationVariantId',\n};\n\n/**\n * The frontend-service name the application-creation workbench identifies itself by.\n *\n * Shared because BOTH sides must agree and neither owns it alone: the workbench sends it as\n * `VITE_FRONTEND_SERVICE_NAME` on every `/application-config` and `/i18n/labels` request, and the\n * companion seeds an entry under exactly this key so the engine's `ApplicationConfigController` can\n * answer instead of refusing with `app_configuration_unknown_frontend_service`.\n *\n * Two string literals in two packages would compile perfectly and fail at runtime with an error that\n * names neither of them.\n */\nexport const WORKBENCH_FRONTEND_SERVICE_NAME = 'application-creation-workbench';\n"]}