@afokapu/atdd-bun 0.10.104 → 0.10.106

package/README.md

@@ -73,6 +73,19 @@ registerEnforcementTest({ root: import.meta.dir + "/..", profiles: ["traceabilit
 
 `planner-nodes/ENFORCEMENT_SCOPE.yaml` says which canonical planner rules have a Bun realization.
 
+### Journey execution strategy conventions
+
+The planner profile exposes Bun-owned `planner.journey.execution-strategies` and eight individual
+strategy patterns: reference, conditional, concurrent, pipelined, batched, cached, speculative,
+and adaptive. Each describes applicability, constraints, evidence, and its actual runtime
+support. Agents discover them through the generated planner profile registry. Strategies
+can combine, but none is mandatory or a runtime mode merely because the convention exists.
+
+Existing journey continuation, interlocking route, and acceptance validators remain strict.
+Convention guidance does **not** enable undeclared fork/join, streaming, or speculative
+execution: these require their own runtime semantics and acceptance evidence.
+
+
 ## Greenfield and brownfield
 
 A greenfield repository enforces every profile from the start: that is the default. A brownfield

package/conventions/_profiles/planner.yaml

@@ -42,8 +42,28 @@ conventions:
     path: "planner-nodes/nodes/planner.feature.wagon-link.convention.yaml"
   - rule_id: "planner.journey.continuation-closure"
     path: "planner-nodes/nodes/planner.journey.continuation-closure.convention.yaml"
+  - rule_id: "planner.journey.definition"
+    path: "planner-nodes/nodes/planner.journey.definition.convention.yaml"
+  - rule_id: "planner.journey.execution-strategies"
+    path: "planner-nodes/nodes/planner.journey.execution-strategies.convention.yaml"
   - rule_id: "planner.journey.interlocking-composed"
     path: "planner-nodes/nodes/planner.journey.interlocking-composed.convention.yaml"
+  - rule_id: "planner.journey.strategy.adaptive"
+    path: "planner-nodes/nodes/planner.journey.strategy.adaptive.convention.yaml"
+  - rule_id: "planner.journey.strategy.batched"
+    path: "planner-nodes/nodes/planner.journey.strategy.batched.convention.yaml"
+  - rule_id: "planner.journey.strategy.cached"
+    path: "planner-nodes/nodes/planner.journey.strategy.cached.convention.yaml"
+  - rule_id: "planner.journey.strategy.concurrent"
+    path: "planner-nodes/nodes/planner.journey.strategy.concurrent.convention.yaml"
+  - rule_id: "planner.journey.strategy.conditional"
+    path: "planner-nodes/nodes/planner.journey.strategy.conditional.convention.yaml"
+  - rule_id: "planner.journey.strategy.pipelined"
+    path: "planner-nodes/nodes/planner.journey.strategy.pipelined.convention.yaml"
+  - rule_id: "planner.journey.strategy.reference"
+    path: "planner-nodes/nodes/planner.journey.strategy.reference.convention.yaml"
+  - rule_id: "planner.journey.strategy.speculative"
+    path: "planner-nodes/nodes/planner.journey.strategy.speculative.convention.yaml"
   - rule_id: "planner.theme.must-be-canonical"
     path: "planner-nodes/nodes/planner.theme.must-be-canonical.convention.yaml"
   - rule_id: "planner.theme.theme-zero-mandatory"
@@ -277,6 +297,16 @@ relationships:
     strength: "important"
     target_ref: "tester.bun.acceptance-binding-declared"
     type: "runs_alongside"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "JourneyRunner executes the continuation topology the plan declares; without a declared journey there is nothing for it to compose"
+    source_ref: "coder.bun.journey-runner-boundary"
+    strength: "critical"
+    target_ref: "planner.journey.definition"
+    type: "requires"
   - confidence: 1
     constraint: "discretionary"
     control: "external"
@@ -337,6 +367,26 @@ relationships:
     strength: "important"
     target_ref: "planner.wagon.features"
     type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "decoding the nominal and sibling trains supplies what a journey composes across interlockings"
+    source_ref: "planner.decomposition.train-journey"
+    strength: "important"
+    target_ref: "planner.journey.definition"
+    type: "enables"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "the journey view is rendered from the journey topology the plan declares"
+    source_ref: "planner.docs.journey-view-current"
+    strength: "critical"
+    target_ref: "planner.journey.definition"
+    type: "requires"
   - confidence: 1
     constraint: "mandatory"
     control: "internal"
@@ -377,6 +427,16 @@ relationships:
     strength: "critical"
     target_ref: "planner.journey.definition"
     type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "execution strategies inherit the existing journey ownership and continuation contract"
+    source_ref: "planner.journey.execution-strategies"
+    strength: "important"
+    target_ref: "planner.journey.definition"
+    type: "requires"
   - confidence: 1
     constraint: "mandatory"
     control: "internal"
@@ -397,6 +457,86 @@ relationships:
     strength: "critical"
     target_ref: "planner.journey.definition"
     type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "the adaptive strategy requires the shared applicability and evidence principles"
+    source_ref: "planner.journey.strategy.adaptive"
+    strength: "important"
+    target_ref: "planner.journey.execution-strategies"
+    type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "the batched strategy requires the shared applicability and evidence principles"
+    source_ref: "planner.journey.strategy.batched"
+    strength: "important"
+    target_ref: "planner.journey.execution-strategies"
+    type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "the cached strategy requires the shared applicability and evidence principles"
+    source_ref: "planner.journey.strategy.cached"
+    strength: "important"
+    target_ref: "planner.journey.execution-strategies"
+    type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "the concurrent strategy requires the shared applicability and evidence principles"
+    source_ref: "planner.journey.strategy.concurrent"
+    strength: "important"
+    target_ref: "planner.journey.execution-strategies"
+    type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "the conditional strategy requires the shared applicability and evidence principles"
+    source_ref: "planner.journey.strategy.conditional"
+    strength: "important"
+    target_ref: "planner.journey.execution-strategies"
+    type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "the pipelined strategy requires the shared applicability and evidence principles"
+    source_ref: "planner.journey.strategy.pipelined"
+    strength: "important"
+    target_ref: "planner.journey.execution-strategies"
+    type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "the reference strategy requires the shared applicability and evidence principles"
+    source_ref: "planner.journey.strategy.reference"
+    strength: "important"
+    target_ref: "planner.journey.execution-strategies"
+    type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "the speculative strategy requires the shared applicability and evidence principles"
+    source_ref: "planner.journey.strategy.speculative"
+    strength: "important"
+    target_ref: "planner.journey.execution-strategies"
+    type: "requires"
   - confidence: 1
     constraint: "mandatory"
     control: "internal"
@@ -787,3 +927,13 @@ relationships:
     strength: "important"
     target_ref: "planner.wagon.urn-naming"
     type: "requires"
+  - confidence: 1
+    constraint: "mandatory"
+    control: "internal"
+    foundation: "finish_to_start"
+    origin: "@afokapu/atdd-bun"
+    reason: "exposed journeys are the ones a journey declares with an exposed entrypoint"
+    source_ref: "tester.htmx.exposed-journey-e2e-coverage"
+    strength: "critical"
+    target_ref: "planner.journey.definition"
+    type: "requires"

package/conventions/coder.bun/coder.bun.duplication-intra-layer.convention.yaml

@@ -57,7 +57,7 @@ content:
   - Trivial lines (bare braces, closing punctuation) are not counted toward the 7.
   - Import and re-export declarations are not counted, because two files importing the same names from one shared module match because the logic was shared, which is the fix this rule asks for.
   - Property signatures inside a `type X = {` or `interface X {` body (optional `readonly`, a name, optional `?`, `:` a type, ending `;` or `,`), including the members of nested object types, are not counted, because two unrelated records with the same number of same-typed fields match once identifiers are folded and neither coupling them nor a cosmetic edit is a fix. Executable statements, object literals, class fields, enum bodies, and method bodies still count.
-  - Files whose layer cannot be determined are compared only against each other.
+  - Files whose layer cannot be determined are not judged, because with no established layer there is no intra-layer comparison and unclassified paths are never compared with each other.
 metadata:
   aliases:
   # DUPLICATION-TS-001 is the SHARED core alias, also carried by the agnostic node and by

package/detectors/bun_ts_metrics_detector/checks/ts_duplication.mjs

@@ -30,6 +30,8 @@ for (const root of readRoots()) {
   for (const f of walk(root, excludes, M.TS_EXT, true)) {
     if (isExcluded(f)) continue;
     const layer = M.determineLayer(f);
+    // A path with no established layer has no "same layer" to be duplicated within.
+    if (layer === "unknown") continue;
     if (!byLayer.has(layer)) byLayer.set(layer, []);
     byLayer.get(layer).push(f);
   }

package/integrity.json

@@ -1,9 +1,8 @@
 {
-  "version": "0.10.104",
+  "version": "0.10.106",
   "files": {
     "HOOK_AUDIT.md": "5329d840db37671b1918f688ead26865473b87db73dbc75f7c8b2a8bbe8d6d43",
-    "PLANNER_PORT.md": "fb5935bac8b7ac18994de21e43ace3a5ef8cd55f85b0e3349fca261280054f11",
-    "README.md": "8f0e45595fc10bb6f033b81b67246e57bb3f5bbaf62b35ba950beb5f9f82a938",
+    "README.md": "8aefceaa24bee498f39081b2aaf4c0d5c54bc1ed9849c20e1d98d1427df56eab",
     "bunfig.toml": "b9fc65eca9014c5179380259d70e76385a6a80788fa9a2df5fb3eaa5554fd2fe",
     "conventions/_profiles/architecture.yaml": "f1808768b720a4e476047e4a0912002ca673946562cea9aeef5d0c214828d93a",
     "conventions/_profiles/coder.yaml": "53693363c6623b5b12ece1c746c8cf4f052615310fc5683160d8de8be7d8e0c9",
@@ -13,7 +12,7 @@
     "conventions/_profiles/htmx.yaml": "38fc8b3e1a53429e16977ed63e83e751b203deffe9b338ea171050fb64641559",
     "conventions/_profiles/interlocking.yaml": "46a2a4fb2eb537941c991ef4178d009a30d14f84279e525ca0d0887d3239047d",
     "conventions/_profiles/metrics.yaml": "82081754271e0cb08a1245ad658578907c8e0e455912aa954502334a82d7b4d3",
-    "conventions/_profiles/planner.yaml": "b3938783793c34f832968b7293b7c301f3e1deff5f06536a078168c911d0d089",
+    "conventions/_profiles/planner.yaml": "f53311e9990881792a5fce07ffbcd9e8b1cc36c5cb82e4e8523f65dcbaef0878",
     "conventions/_profiles/runtime.yaml": "48fae0d31fb9228b8819243c264721037720acb1763bf27f74325c14ffef46d4",
     "conventions/_profiles/security.yaml": "38eb6b17e35e1439fe4f19c8ccf3ba1b2f18759a984dd1d33171ec3a29128876",
     "conventions/_profiles/telemetry.yaml": "4c07c693357fad420df0df82a3ad196cd159df017fec6b98244841530516dfd9",
@@ -59,7 +58,7 @@
     "conventions/coder.bun/coder.bun.dto-mapper.convention.yaml": "c524b5f37db6ae4f7558fc3ec672aa1c5b764738a0f25a20062d736fed6bbcb3",
     "conventions/coder.bun/coder.bun.dto-placement.convention.yaml": "9525255f9e037ca0d939de20e70235fe348dcebf2136536055bc21433d7e9fb5",
     "conventions/coder.bun/coder.bun.dto-purity.convention.yaml": "4743199fb242a25f896425916e3873c2e8cf62f4285437f62b0f8f8139d6a58d",
-    "conventions/coder.bun/coder.bun.duplication-intra-layer.convention.yaml": "023310241a28e6a7aad5cf020bd1b9d4e05a887ddd92dbcd4c13b8a45e26ae6e",
+    "conventions/coder.bun/coder.bun.duplication-intra-layer.convention.yaml": "c3de56dbe9bef4d199abfceb2cf9b702a54b2683d437305466ca15b009cf3067",
     "conventions/coder.bun/coder.bun.error-response-bare-string.convention.yaml": "c2c0f859f6dd12702edf225c4148849e72b6c25e6d7cd28edd5d644ba277a23c",
     "conventions/coder.bun/coder.bun.error-response-code-format.convention.yaml": "3048fed00b92c2559f7c52f73cfcce07b583eb47b12d04f0851e237ae3646567",
     "conventions/coder.bun/coder.bun.green-header-order.convention.yaml": "2a42d67bedeec1de76fa1de844351983c5ba4bc5b61d5a5047298f6804664f67",
@@ -718,7 +717,7 @@
     "detectors/bun_ts_metrics_detector/checks/ts_complexity_length.mjs": "e49fe93dbf2c52a91fe97b1e0b810d60f7d34d43581dfb96d4827640e6f5e3fd",
     "detectors/bun_ts_metrics_detector/checks/ts_complexity_nesting.mjs": "8d8f61ea1748f33b037beb3f3fe5c84acbce395575e24fb1d01432813762e4d1",
     "detectors/bun_ts_metrics_detector/checks/ts_dead_code.mjs": "8f2205274f5056993a888ea4141be4d0b64c287e4641d0a464d178530b5297d4",
-    "detectors/bun_ts_metrics_detector/checks/ts_duplication.mjs": "12b5087c34741ce3fde573059d1afbaafc80ce1bfe8a235780113fd558dbbc7d",
+    "detectors/bun_ts_metrics_detector/checks/ts_duplication.mjs": "4c34fe8494a492e4cbaf5c946a272485e0f01b1f8c638d1f442e13ad5b05b3d4",
     "detectors/bun_ts_metrics_detector/checks/ts_quality_comments.mjs": "872d71d2165eba4cb39c975b09365cf67a64f1db5c55c0df9e86ff411e02ea31",
     "detectors/bun_ts_metrics_detector/checks/ts_quality_mi.mjs": "69765d88441e98f4f38b7da0a416b7dab8b7f0072e562ea9d40d399802452067",
     "detectors/bun_ts_metrics_detector/detect.mjs": "a3eef9ad7b18a5743e508f5ac8c54cdf601cead679ed832629bfd4936d2ce6df",
@@ -1036,7 +1035,7 @@
     "lib/interlocking.mjs": "d0803d080ac7d7477c51be70112df1e85213d339fd3c6b71f75f26145fa8accd",
     "lib/journey-chain.mjs": "34b1efa073b17940fa398af2970c85bb2fac35e4b2608ce635cfb6c39e3adc53",
     "lib/scan.mjs": "b6973e411ecd14c548a055c871e01e948f002b772042136be8401f38d998e687",
-    "planner-nodes/ENFORCEMENT_SCOPE.yaml": "d8ec7039c219857f3d77af5d4d84612b533b69c1a5fcef935fbf46470adafed4",
+    "planner-nodes/ENFORCEMENT_SCOPE.yaml": "47aa9c78a4bb1754c6b435f5e056038baa04a24cd48df2c205db2bc08a3a3cac",
     "planner-nodes/nodes/planner.acceptance.abstract-fields-required.convention.yaml": "bd565693f0ae861f0561ad2f7a91a8c55f9a209c3acd59c5750cfcffd96a85d8",
     "planner-nodes/nodes/planner.acceptance.authoring-guidelines.convention.yaml": "16348dceed5868041b832bde766e9c8d4a950d4032f1f3066b357644081a3b17",
     "planner-nodes/nodes/planner.acceptance.boundary-kind-vocabulary.convention.yaml": "c5645225399568c2d4fe632442f9c597b2c59e4f4239880df7db2cbdc0353c9c",
@@ -1143,7 +1142,16 @@
     "planner-nodes/nodes/planner.issue-body.graph-context-required.convention.yaml": "6292ab37efda9fbdd1e028283bed7c594baa4e070266795180a3bcded2760621",
     "planner-nodes/nodes/planner.journey.continuation-closure.convention.yaml": "56c447b05cfe98804ea53bdde68ad940138093a4341620872e9b5c61be08869c",
     "planner-nodes/nodes/planner.journey.definition.convention.yaml": "a163bb9d5140d17a0dac996d84a8efc9f833592407dbebaec94db25006e88e28",
+    "planner-nodes/nodes/planner.journey.execution-strategies.convention.yaml": "639f035af31ba3daabd79c59dfaa338ab7179ff9f89691f2b7c8a485bd1adecc",
     "planner-nodes/nodes/planner.journey.interlocking-composed.convention.yaml": "91d3f1a9061a1fccaeeb52a07f1459f93f665d310dc453fecbd5db23c603a7ec",
+    "planner-nodes/nodes/planner.journey.strategy.adaptive.convention.yaml": "59d97a125d6a9ce8b470b0614a950008438d63fe31c9ea53d251c282ba75a779",
+    "planner-nodes/nodes/planner.journey.strategy.batched.convention.yaml": "e8eec802f9eec2b075a92f965e1d8850bb39093ac03c355230ed839d0b8d513a",
+    "planner-nodes/nodes/planner.journey.strategy.cached.convention.yaml": "cabd71aa928248f4e27150f8598db69da7c7d5800f96f21ee0b6ec449ba7dac7",
+    "planner-nodes/nodes/planner.journey.strategy.concurrent.convention.yaml": "1e761656f17ef6a33e827fc670dbadf766cacd705c994b239771dc465a6620c5",
+    "planner-nodes/nodes/planner.journey.strategy.conditional.convention.yaml": "ed3d075ece7b26f79ca31f00279ca82db604b81653a4b3da1b7a67190c353a7d",
+    "planner-nodes/nodes/planner.journey.strategy.pipelined.convention.yaml": "c13e8d0c5a9ed82f245d97fd097c6fbef21ecf7982657d63e219a1a2e3c939a4",
+    "planner-nodes/nodes/planner.journey.strategy.reference.convention.yaml": "52e5db6b87e9800f7891208a66bb553c222fb465c95f219ab1918adc3dcc8298",
+    "planner-nodes/nodes/planner.journey.strategy.speculative.convention.yaml": "6c925be358e9faf0858faca7477ff64361ec81aa66b28b608b1dc6acad504d22",
     "planner-nodes/nodes/planner.plan.confirm-before-author.convention.yaml": "23116f68ce81ff78ab57d362cf7195c4bf637781d74df4aece4d61eafbf0a49b",
     "planner-nodes/nodes/planner.plan.confirm-binds-an-issue.convention.yaml": "27de0e84fb7181a6768c65c30865fecdf94a3beddc3a47a4d6de226aaf014767",
     "planner-nodes/nodes/planner.plan.confirm-requires-interlocking-sanity.convention.yaml": "7ae7d9c6c70d0f4d3e50ae81f1d9f18ee1f70f348bee33147ee99d2d3d4a4de4",
@@ -1255,13 +1263,13 @@
     "planner-schemas/train.schema.json": "d6fbac9067c1bffeb84eb79a71228441055af6e6e7ba141dd4e0bcb079345ec0",
     "planner-schemas/wagon.schema.json": "12353e46d2216d2deef754615b629a696bd8a7bb35326379e7ef2b221a5ece3a",
     "planner-schemas/wmbt.schema.json": "7a3a5693bfcf01340667c2be4a3c48e74f34b1af7e8dc13372c0de06b7f4fe12",
-    "relationships.yaml": "fccaf745b383fe527b7db9022233037bdf5b5cc3d495bb40da3cca4746f5e241",
+    "relationships.yaml": "af7b9d56fd52e00b10845ac4c5bcbec77a44338c0aaa29b548aa7fa53eba4c59",
     "src/agent.ts": "6d6c6e75908af8fbab13432f0001b0374bb25cf3dee46ba218dfd67e0090cb56",
     "src/ci.ts": "b5c57dd87fc780b2b272156b68830d14e695a1a28300dec46a06f71864e0c59e",
     "src/cli.ts": "395638ab87565bb10c2beb35988ff1acf686924d13515795156a2e8893b3da88",
     "src/docs-capability.ts": "bdeeb414649049b1cd4fa8008cada3a576318be51c43bec91bfa46a8e250c270",
-    "src/enforce.ts": "e0c10519aeecd7080f2900ea230fad2f09482af47c1cee885d5de71573e29732",
-    "src/hooks.ts": "62a0557c5914fc56abc3ca4900a86ba333e6a92938e75a39d46ebaee0af4f0b0",
+    "src/enforce.ts": "c4811abe63efe4568f3cf26e21a152d1537e120cb3ce471daca32367cf6e2cda",
+    "src/hooks.ts": "7e3dd5518701d2f3399bee919a68e801588822b173a648ed738c05c4a57231f1",
     "src/index.ts": "4081f8b08d1d3ee9e15a9964143e53d9cfb94a5616ab3e58a180d24cc16dc381",
     "src/integrity.ts": "f1ede7cb04924ae88e11917047277e264af6596b9759e381bd9c497cd34a797d",
     "src/journey-docs.ts": "994d229376244c84212cff951032823068a76565dd2fd427b9d44e341bd14853",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afokapu/atdd-bun",
-  "version": "0.10.104",
+  "version": "0.10.106",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/afokapu/atdd-bun.git"

package/planner-nodes/ENFORCEMENT_SCOPE.yaml

@@ -1,15 +1,15 @@
 schema_version: "1.0.0"
 package: "@afokapu/atdd-bun"
 node_corpus:
-  source: "src/atdd/planner/conventions/nodes/"
-  count: 196
+  source: "planner-nodes/nodes/"
+  count: 205
   policy: >-
-    Every node is shipped as canonical planner reference material. A node is not
+    Every node is shipped as Bun-owned planner reference material. A node is not
     represented as enforced merely because it is present in this corpus.
 
 # A provider implementation must name every canonical rule it realizes. `disposition` is
 # this package's enforcement, always strict: atdd-bun fails on every finding, whatever the
-# canonical node's own metadata says (the nodes are shipped verbatim). `coverage`
+# canonical node's own metadata says (the nodes are authored and shipped by ATDD Bun). `coverage`
 # describes the Bun predicate actually exercised, not an assertion that the entire
 # prose convention has been ported.
 canonical_bun_enforcement:
@@ -140,7 +140,7 @@ canonical_bun_enforcement:
 
 reference_only:
   selection: "every canonical planner node not named in canonical_bun_enforcement"
-  count: 180
+  count: 189
 
 package_integrity_guard:
   implementation_id: planner.plan-integrity.bun

package/planner-nodes/nodes/planner.journey.execution-strategies.convention.yaml

@@ -0,0 +1,27 @@
+schema_version: 1.0.0
+rule_id: planner.journey.execution-strategies
+kind: family
+status: active
+name: Journey execution strategy catalog
+statement: >-
+    Journey strategies are candidate ways to meet declared behavioral obligations. Choose for latency, throughput, cost, reliability, determinism, and complexity requirements; none is universally best. This convention does not authorize bypassing interlockings, trains, continuations, or acceptances.
+terms:
+  - term_id: selection
+    text: >-
+      Begin with the reference strategy, then consider alternatives only when requirements or measured workloads justify complexity. Strategies are orthogonal and can combine.
+  - term_id: ownership
+    text: >-
+      Interlockings select guarded alternatives, journeys compose control flow, trains remain linear, and wagons can optimize their internals.
+  - term_id: governance
+    text: >-
+      Use only execution behavior actually supported by the plan and runtime. Missing fork/join, stream, or speculation capability requires separate implementation and accepted proof.
+  - term_id: evidence
+    text: >-
+      Preserve contracts, artifacts, prerequisites, side effects, error paths and terminal outcomes. Behavioral tests establish equivalence; reproducible benchmarks support performance claims. Observable behavior changes need their own accepted route.
+notes: >-
+  Bun-owned planner guidance, not a new runtime mode or an independently enforced rule.
+  Existing journey, interlocking, and acceptance validators remain authoritative.
+metadata:
+  severity: 3
+  disposition: advisory
+  introduced_in: 0.1.0

package/planner-nodes/nodes/planner.journey.strategy.adaptive.convention.yaml

@@ -0,0 +1,28 @@
+schema_version: 1.0.0
+rule_id: planner.journey.strategy.adaptive
+kind: pattern
+status: active
+name: Adaptive selection
+statement: >-
+    Choose among already declared valid strategies using workload or resource signals while preserving accepted outputs and route obligations.
+terms:
+  - term_id: applicability
+    text: >-
+      Consider only where measured workload variation justifies multiple strategies and switching overhead.
+  - term_id: constraints
+    text: >-
+      Use a deterministic inspectable selection policy and stable fallback; do not invent routes or suppress failure behavior when signals are absent.
+  - term_id: evidence
+    text: >-
+      Test thresholds, missing metrics, fallback, oscillation and equivalence across workload classes; benchmark total cost.
+  - term_id: runtime_boundary
+    text: >-
+      Interlocking guards support deterministic alternatives; dynamic rescheduling needs new validated capabilities.
+notes: >-
+  Guidance for agents, not independent enforcement or a new runtime dispatch option.
+  Existing plan and source validators apply. Unimplemented orchestration behavior
+  cannot be inferred from a pattern.
+metadata:
+  severity: 3
+  disposition: advisory
+  introduced_in: 0.1.0

package/planner-nodes/nodes/planner.journey.strategy.batched.convention.yaml

@@ -0,0 +1,28 @@
+schema_version: 1.0.0
+rule_id: planner.journey.strategy.batched
+kind: pattern
+status: active
+name: Batched or fused work
+statement: >-
+    Combine compatible calls or computations to amortize I/O, setup, serialization or scheduling overhead without changing accepted logical results.
+terms:
+  - term_id: applicability
+    text: >-
+      Use for repeated homogeneous operations, database queries, vectorizable computation or repeated setup.
+  - term_id: constraints
+    text: >-
+      Preserve item identity, failure independence, transaction/authority boundaries, order and resource limits. Do not fuse across wagon ownership merely to reduce calls.
+  - term_id: evidence
+    text: >-
+      Test mixed outcomes, batch boundaries, item-result mapping and equivalence; measure throughput and tail latency.
+  - term_id: runtime_boundary
+    text: >-
+      Normally an internal wagon implementation; no journey or interlocking schema change is needed.
+notes: >-
+  Guidance for agents, not independent enforcement or a new runtime dispatch option.
+  Existing plan and source validators apply. Unimplemented orchestration behavior
+  cannot be inferred from a pattern.
+metadata:
+  severity: 3
+  disposition: advisory
+  introduced_in: 0.1.0

package/planner-nodes/nodes/planner.journey.strategy.cached.convention.yaml

@@ -0,0 +1,28 @@
+schema_version: 1.0.0
+rule_id: planner.journey.strategy.cached
+kind: pattern
+status: active
+name: Cached or incremental results
+statement: >-
+    Reuse valid results or recompute only affected portions when freshness and invalidation contracts make reuse safe.
+terms:
+  - term_id: applicability
+    text: >-
+      Use for expensive repeatable reads and derivations with stable identities and tractable dependencies.
+  - term_id: constraints
+    text: >-
+      Define cache key, freshness, invalidation, authorization, tenant isolation and side effects. A hit cannot omit required permission or mutation.
+  - term_id: evidence
+    text: >-
+      Test cold/warm paths, staleness, invalidation races, isolation and accepted-result equivalence; measure hit rate.
+  - term_id: runtime_boundary
+    text: >-
+      Cache work can be internal to a wagon; an explicit hit/miss route can use an existing interlocking.
+notes: >-
+  Guidance for agents, not independent enforcement or a new runtime dispatch option.
+  Existing plan and source validators apply. Unimplemented orchestration behavior
+  cannot be inferred from a pattern.
+metadata:
+  severity: 3
+  disposition: advisory
+  introduced_in: 0.1.0

package/planner-nodes/nodes/planner.journey.strategy.concurrent.convention.yaml

@@ -0,0 +1,28 @@
+schema_version: 1.0.0
+rule_id: planner.journey.strategy.concurrent
+kind: pattern
+status: active
+name: Concurrent branches
+statement: >-
+    Run independent journey branches in parallel only when the topology explicitly specifies fan-out, dependency release, join, and failure semantics.
+terms:
+  - term_id: applicability
+    text: >-
+      Use for independent expensive operations whose measured saving exceeds concurrency overhead.
+  - term_id: constraints
+    text: >-
+      Multiple incoming continuations are not a synchronization join. Current journeys allow one outgoing continuation or terminal per route and do not provide fork/join semantics.
+  - term_id: evidence
+    text: >-
+      Prove bounded concurrency, prerequisite satisfaction, joining, cancellation, failures and result equivalence; benchmark latency.
+  - term_id: runtime_boundary
+    text: >-
+      Cross-interlocking fan-out/fan-in is not yet supported. Within-wagon concurrency can honor existing contracts.
+notes: >-
+  Guidance for agents, not independent enforcement or a new runtime dispatch option.
+  Existing plan and source validators apply. Unimplemented orchestration behavior
+  cannot be inferred from a pattern.
+metadata:
+  severity: 3
+  disposition: advisory
+  introduced_in: 0.1.0

package/planner-nodes/nodes/planner.journey.strategy.conditional.convention.yaml

@@ -0,0 +1,28 @@
+schema_version: 1.0.0
+rule_id: planner.journey.strategy.conditional
+kind: pattern
+status: active
+name: Guarded alternative
+statement: >-
+    Use an interlocking's deterministic guards and priorities to select among declared linear train variants. A shortcut is a declared route, not an undeclared bypass.
+terms:
+  - term_id: applicability
+    text: >-
+      Use for workload classes, cache hit/miss, fallbacks, recovery paths, or other mutually selected alternatives.
+  - term_id: constraints
+    text: >-
+      Every branch must have declared guard, train and accepted artifacts. Ambiguous matching and changed observable behavior are invalid without new acceptance.
+  - term_id: evidence
+    text: >-
+      Test matching and nonmatching guards, ambiguity/priority resolution, errors and contract preservation.
+  - term_id: runtime_boundary
+    text: >-
+      Supported by current interlocking route resolution and journey continuations.
+notes: >-
+  Guidance for agents, not independent enforcement or a new runtime dispatch option.
+  Existing plan and source validators apply. Unimplemented orchestration behavior
+  cannot be inferred from a pattern.
+metadata:
+  severity: 3
+  disposition: advisory
+  introduced_in: 0.1.0

package/planner-nodes/nodes/planner.journey.strategy.pipelined.convention.yaml

@@ -0,0 +1,28 @@
+schema_version: 1.0.0
+rule_id: planner.journey.strategy.pipelined
+kind: pattern
+status: active
+name: Pipelined execution
+statement: >-
+    Overlap producers and consumers through incremental artifact delivery only with an explicit streaming protocol.
+terms:
+  - term_id: applicability
+    text: >-
+      Use for streaming/chunked workloads where first-result latency or memory dominates.
+  - term_id: constraints
+    text: >-
+      Preserve backpressure, ordering, partial failure, stream completion and resource bounds. A standard journey handoff does not define streaming.
+  - term_id: evidence
+    text: >-
+      Test slow consumers, bounded buffers, chunk order, interruptions and equivalence; measure throughput and first-result latency.
+  - term_id: runtime_boundary
+    text: >-
+      Internal wagon streaming is possible; cross-interlocking streaming requires new declared runtime semantics.
+notes: >-
+  Guidance for agents, not independent enforcement or a new runtime dispatch option.
+  Existing plan and source validators apply. Unimplemented orchestration behavior
+  cannot be inferred from a pattern.
+metadata:
+  severity: 3
+  disposition: advisory
+  introduced_in: 0.1.0

package/planner-nodes/nodes/planner.journey.strategy.reference.convention.yaml

@@ -0,0 +1,28 @@
+schema_version: 1.0.0
+rule_id: planner.journey.strategy.reference
+kind: pattern
+status: active
+name: Reference execution
+statement: >-
+    Follow declared interlocking routes and train continuations without additional scheduling or speculative transformations. Reference is the default, not a mandated slow path.
+terms:
+  - term_id: applicability
+    text: >-
+      Choose when ordering matters, workload is small, behavior must be reproduced, or performance evidence does not justify an alternative.
+  - term_id: constraints
+    text: >-
+      Preserve guards, error/exception routes, artifacts, terminal outcomes, side effects, and ordering. A nominal path is not the full route space.
+  - term_id: evidence
+    text: >-
+      Use existing journey and acceptance tests to prove behavior; gather baseline measurements before claiming another strategy is faster.
+  - term_id: runtime_boundary
+    text: >-
+      Supported by the current single-route continuation model.
+notes: >-
+  Guidance for agents, not independent enforcement or a new runtime dispatch option.
+  Existing plan and source validators apply. Unimplemented orchestration behavior
+  cannot be inferred from a pattern.
+metadata:
+  severity: 3
+  disposition: advisory
+  introduced_in: 0.1.0

package/planner-nodes/nodes/planner.journey.strategy.speculative.convention.yaml

@@ -0,0 +1,28 @@
+schema_version: 1.0.0
+rule_id: planner.journey.strategy.speculative
+kind: pattern
+status: active
+name: Speculative execution
+statement: >-
+    Initiate reversible likely-needed work early only when discarded work and cancellation cannot change accepted behavior.
+terms:
+  - term_id: applicability
+    text: >-
+      Consider when expensive future work is predictable and wasted work can be budgeted.
+  - term_id: constraints
+    text: >-
+      Never speculate authority commits, irreversible side effects, externally visible mutations or unauthorized data access. Define isolation, cancellation and resource budgets.
+  - term_id: evidence
+    text: >-
+      Test wrong predictions, cancellation races, duplicate attempts, isolation and total wasted work; measure net benefit.
+  - term_id: runtime_boundary
+    text: >-
+      No generic speculative journey scheduler exists; this convention cannot authorize undeclared execution.
+notes: >-
+  Guidance for agents, not independent enforcement or a new runtime dispatch option.
+  Existing plan and source validators apply. Unimplemented orchestration behavior
+  cannot be inferred from a pattern.
+metadata:
+  severity: 3
+  disposition: advisory
+  introduced_in: 0.1.0

package/relationships.yaml

@@ -7,7 +7,7 @@
 # are not imported; several do not relate two conventions at all.
 schema_version: 1.0.0
 graph_id: "@afokapu/atdd-bun"
-nodes: 
+nodes:
   - atdd-bun.planner.acceptance-identity
   - atdd-bun.planner.identity-required
   - atdd-bun.planner.identity-unique
@@ -213,7 +213,16 @@ nodes:
   - planner.issue-body.graph-context-required
   - planner.journey.continuation-closure
   - planner.journey.definition
+  - planner.journey.execution-strategies
   - planner.journey.interlocking-composed
+  - planner.journey.strategy.adaptive
+  - planner.journey.strategy.batched
+  - planner.journey.strategy.cached
+  - planner.journey.strategy.concurrent
+  - planner.journey.strategy.conditional
+  - planner.journey.strategy.pipelined
+  - planner.journey.strategy.reference
+  - planner.journey.strategy.speculative
   - planner.plan.confirm-before-author
   - planner.plan.confirm-binds-an-issue
   - planner.plan.confirm-requires-interlocking-sanity
@@ -5279,3 +5288,93 @@ edges:
     target_ref: coder.bun.phase-discipline
     type: follows
     origin: "@afokapu/atdd-bun"
+  - confidence: 1
+    constraint: mandatory
+    control: internal
+    foundation: finish_to_start
+    reason: execution strategies inherit the existing journey ownership and continuation contract
+    source_ref: planner.journey.execution-strategies
+    strength: important
+    target_ref: planner.journey.definition
+    type: requires
+    origin: "@afokapu/atdd-bun"
+  - confidence: 1
+    constraint: mandatory
+    control: internal
+    foundation: finish_to_start
+    reason: the reference strategy requires the shared applicability and evidence principles
+    source_ref: planner.journey.strategy.reference
+    strength: important
+    target_ref: planner.journey.execution-strategies
+    type: requires
+    origin: "@afokapu/atdd-bun"
+  - confidence: 1
+    constraint: mandatory
+    control: internal
+    foundation: finish_to_start
+    reason: the conditional strategy requires the shared applicability and evidence principles
+    source_ref: planner.journey.strategy.conditional
+    strength: important
+    target_ref: planner.journey.execution-strategies
+    type: requires
+    origin: "@afokapu/atdd-bun"
+  - confidence: 1
+    constraint: mandatory
+    control: internal
+    foundation: finish_to_start
+    reason: the concurrent strategy requires the shared applicability and evidence principles
+    source_ref: planner.journey.strategy.concurrent
+    strength: important
+    target_ref: planner.journey.execution-strategies
+    type: requires
+    origin: "@afokapu/atdd-bun"
+  - confidence: 1
+    constraint: mandatory
+    control: internal
+    foundation: finish_to_start
+    reason: the pipelined strategy requires the shared applicability and evidence principles
+    source_ref: planner.journey.strategy.pipelined
+    strength: important
+    target_ref: planner.journey.execution-strategies
+    type: requires
+    origin: "@afokapu/atdd-bun"
+  - confidence: 1
+    constraint: mandatory
+    control: internal
+    foundation: finish_to_start
+    reason: the batched strategy requires the shared applicability and evidence principles
+    source_ref: planner.journey.strategy.batched
+    strength: important
+    target_ref: planner.journey.execution-strategies
+    type: requires
+    origin: "@afokapu/atdd-bun"
+  - confidence: 1
+    constraint: mandatory
+    control: internal
+    foundation: finish_to_start
+    reason: the cached strategy requires the shared applicability and evidence principles
+    source_ref: planner.journey.strategy.cached
+    strength: important
+    target_ref: planner.journey.execution-strategies
+    type: requires
+    origin: "@afokapu/atdd-bun"
+  - confidence: 1
+    constraint: mandatory
+    control: internal
+    foundation: finish_to_start
+    reason: the speculative strategy requires the shared applicability and evidence principles
+    source_ref: planner.journey.strategy.speculative
+    strength: important
+    target_ref: planner.journey.execution-strategies
+    type: requires
+    origin: "@afokapu/atdd-bun"
+  - confidence: 1
+    constraint: mandatory
+    control: internal
+    foundation: finish_to_start
+    reason: the adaptive strategy requires the shared applicability and evidence principles
+    source_ref: planner.journey.strategy.adaptive
+    strength: important
+    target_ref: planner.journey.execution-strategies
+    type: requires
+    origin: "@afokapu/atdd-bun"

package/src/enforce.ts

@@ -44,7 +44,18 @@ export const profileImplementations: Record<ConcreteProfile, string[]> = {
 
 /** Additional policy conventions a profile loads, whether local or contributed by an installed companion package. */
 export const profileConventions: Record<ConcreteProfile, Array<{ rule_id: string; path: string }>> = {
-  traceability: [], topology: [], docs: [], planner: [], telemetry: [], coder: [{ rule_id: "coder.bun.phase-discipline", path: "conventions/coder.bun/coder.bun.phase-discipline.convention.yaml" }], tester: [], security: [],
+  traceability: [], topology: [], docs: [], planner: [
+    { rule_id: "planner.journey.definition", path: "planner-nodes/nodes/planner.journey.definition.convention.yaml" },
+    { rule_id: "planner.journey.execution-strategies", path: "planner-nodes/nodes/planner.journey.execution-strategies.convention.yaml" },
+    { rule_id: "planner.journey.strategy.adaptive", path: "planner-nodes/nodes/planner.journey.strategy.adaptive.convention.yaml" },
+    { rule_id: "planner.journey.strategy.batched", path: "planner-nodes/nodes/planner.journey.strategy.batched.convention.yaml" },
+    { rule_id: "planner.journey.strategy.cached", path: "planner-nodes/nodes/planner.journey.strategy.cached.convention.yaml" },
+    { rule_id: "planner.journey.strategy.concurrent", path: "planner-nodes/nodes/planner.journey.strategy.concurrent.convention.yaml" },
+    { rule_id: "planner.journey.strategy.conditional", path: "planner-nodes/nodes/planner.journey.strategy.conditional.convention.yaml" },
+    { rule_id: "planner.journey.strategy.pipelined", path: "planner-nodes/nodes/planner.journey.strategy.pipelined.convention.yaml" },
+    { rule_id: "planner.journey.strategy.reference", path: "planner-nodes/nodes/planner.journey.strategy.reference.convention.yaml" },
+    { rule_id: "planner.journey.strategy.speculative", path: "planner-nodes/nodes/planner.journey.strategy.speculative.convention.yaml" },
+  ], telemetry: [], coder: [{ rule_id: "coder.bun.phase-discipline", path: "conventions/coder.bun/coder.bun.phase-discipline.convention.yaml" }], tester: [], security: [],
   architecture: [], metrics: [], runtime: [], interlocking: [], htmx: [], design: [],
   flow: [
     { rule_id: "atdd-bun.review.behavioral-reconciliation", path: "conventions/atdd-bun.review/atdd-bun.review.behavioral-reconciliation.convention.yaml" },

package/src/hooks.ts

@@ -471,7 +471,7 @@ async function createWorkspace(state: Layout, target: { leaf: string; target: st
   return bad(bookmark.err || bookmark.out || `bookmark ${branch} was not exported to the colocated Git repository`);
 }
 
-async function finishCandidate(state: Layout, cfg: HookPolicy): Promise<{ error: string } | { branch: string; tip: string; name: string }> {
+async function finishCandidate(state: Layout, cfg: HookPolicy): Promise<{ error: string } | { branch: string; tip: string }> {
   if (state.current === state.primary || !inside(state.worktreeRoot, state.current)) return { error: `finish must run from a linked workspace beneath ${state.worktreeRoot}` };
   const conflict = await noConflicts(state.current);
   if (conflict.error !== undefined) return conflict;
@@ -489,23 +489,50 @@ async function finishCandidate(state: Layout, cfg: HookPolicy): Promise<{ error:
   }
   const tip = await branchCommit(state.primary, found.branch);
   if (!tip || tip !== delivery) return { error: `bookmark ${found.branch} must point at the delivery revision before finish` };
-  if ((await git(state.primary, ["merge-base", "--is-ancestor", tip, cfg.worktrees.primary_branch])).code) return { error: `branch ${found.branch} is not merged into ${cfg.worktrees.primary_branch} in the primary checkout` };
-  return { branch: found.branch, tip, name: branchPath(found.branch) };
+  const undelivered = await deliveryError(state, found.branch, tip, cfg);
+  return undelivered ? { error: undelivered } : { branch: found.branch, tip };
+}
+
+async function jjRevision(root: string, commit: string): Promise<{ error: string } | { empty: boolean; conflict: boolean; parents: string[] }> {
+  const info = await jj(root, ["log", "-r", commit, "--no-graph", "-T", 'if(empty, "empty", "content") ++ " " ++ if(conflict, "conflict", "clean") ++ " " ++ parents.map(|p| p.commit_id()).join(" ")']);
+  if (info.code || !info.out) return { error: `could not inspect Jujutsu revision ${commit}: ${info.err || info.out}` };
+  const [emptiness, conflict, ...parents] = info.out.split(" ");
+  return { empty: emptiness === "empty", conflict: conflict === "conflict", parents };
+}
+
+// A tip is delivered when it is an ancestor of the protected branch, or when it
+// reaches such an ancestor only through empty single-parent changes (nothing to
+// deliver). Content, conflicts, or merge shapes outside that chain fail closed.
+async function deliveryError(state: Layout, branch: string, tip: string, cfg: HookPolicy): Promise<string | null> {
+  let commit = tip;
+  for (;;) {
+    const info = await jjRevision(state.primary, commit);
+    if ("error" in info) return info.error;
+    if (info.conflict) return `bookmark ${branch} has unresolved conflicts`;
+    if (!(await git(state.primary, ["merge-base", "--is-ancestor", commit, cfg.worktrees.primary_branch])).code) return null;
+    if (!info.empty || info.parents.length !== 1) return `branch ${branch} is not merged into ${cfg.worktrees.primary_branch} in the primary checkout`;
+    commit = info.parents[0]!;
+  }
 }
 
-// The sanitized bookmark name is not sufficient authority to remove a workspace;
-// verify the JJ registry resolves that name back to the exact current path.
-async function verifyWorkspace(state: Layout, candidate: { name: string }) {
-  const recorded = await jj(state.primary, ["workspace", "root", "--name", candidate.name]);
-  if (recorded.code) return `workspace ${candidate.name} is not registered: ${recorded.err || recorded.out}`;
-  const recordedPath = await realpath(recorded.out).catch(() => null);
-  return recordedPath === state.current ? null : `workspace ${candidate.name} resolves to ${recorded.out}, not ${state.current}`;
+// The workspace name is never derived from the bookmark (bookmarks can be
+// renamed). Resolve it from the JJ registry: exactly one registered workspace
+// must resolve, by real path, to the current directory.
+async function resolveWorkspace(state: Layout): Promise<{ error: string } | { name: string }> {
+  const listed = await jj(state.primary, ["workspace", "list", "-T", 'name ++ "\\n"']);
+  if (listed.code) return { error: `could not list Jujutsu workspaces: ${listed.err || listed.out}` };
+  const matches: string[] = [];
+  for (const name of listed.out.split("\n").filter(Boolean)) {
+    const recorded = await jj(state.primary, ["workspace", "root", "--name", name]);
+    if (!recorded.code && await realpath(recorded.out).catch(() => null) === state.current) matches.push(name);
+  }
+  return matches.length === 1 ? { name: matches[0]! } : { error: `${state.current} is not registered as exactly one Jujutsu workspace; found ${matches.length}` };
 }
 
 async function deleteBookmark(state: Layout, candidate: { branch: string; tip: string }, cfg: HookPolicy) {
   const now = await branchCommit(state.primary, candidate.branch);
-  const merged = !(await git(state.primary, ["merge-base", "--is-ancestor", candidate.tip, cfg.worktrees.primary_branch])).code;
-  if (now !== candidate.tip || !merged) return `workspace removed, but bookmark ${candidate.branch} was not deleted: its tip changed or is no longer merged into ${cfg.worktrees.primary_branch}`;
+  const merged = now === candidate.tip && !(await deliveryError(state, candidate.branch, candidate.tip, cfg));
+  if (!merged) return `workspace removed, but bookmark ${candidate.branch} was not deleted: its tip changed or is no longer merged into ${cfg.worktrees.primary_branch}`;
   const deleted = await jj(state.primary, ["bookmark", "delete", candidate.branch]);
   return deleted.code ? `workspace removed, but bookmark deletion failed: ${deleted.err || deleted.out}` : null;
 }
@@ -531,9 +558,9 @@ async function finishJjWorktree(root: string, deleteBranch: boolean, cfg: HookPo
   if ("error" in state) return bad(state.error);
   const candidate = await finishCandidate(state, cfg);
   if ("error" in candidate) return bad(candidate.error);
-  const mismatch = await verifyWorkspace(state, candidate);
-  if (mismatch) return bad(mismatch);
-  const removed = await jj(state.primary, ["workspace", "remove", candidate.name]);
+  const workspace = await resolveWorkspace(state);
+  if ("error" in workspace) return bad(workspace.error);
+  const removed = await jj(state.primary, ["workspace", "remove", workspace.name]);
   if (removed.code) return bad(removed.err || removed.out);
   if (!deleteBranch) return { ok: true, message: `removed merged Jujutsu workspace ${state.current}` };
   const deletionError = await deleteBookmark(state, candidate, cfg);

package/PLANNER_PORT.md

@@ -1,55 +0,0 @@
-# Planner port boundary
-
-This package is Python-free for Bun enforcement. It deliberately does not claim
-to port ATDD's full planner yet.
-
-## Portable planner kernel
-
-The package ships 196 canonical convention nodes in `planner-nodes/` and
-21 schemas in `planner-schemas/`. It does not ship Python validator files:
-they are executable Python/pytest code, not portable package assets. Port each
-selected validator into Bun/TypeScript before enabling it in a `planner` profile.
-
-1. Plan artifact schemas and canonical paths: wagon, feature, WMBT, acceptance,
-   train, contract, interlocking, and journey-topology documents.
-2. URN and naming grammar, including wagon/feature/WMBT chains.
-3. Plan graph references: wagon-to-feature, WMBT-to-acceptance, train registry
-   and participant/sequence references, contract registry references.
-4. Static interlocking route declarations and their digest/registry invariants.
-5. Journey topology closure across interlockings, bound through artifacts produced by the selected train.
-
-## Port status
-
-Enabled in the Bun `planner` profile (clean against ATDD's current plan and with a
-dirty fixture per emitted rule):
-
-- wagon identity and duplicate wagon slugs;
-- wagon URN naming;
-- duplicate produced artifact and feature declarations;
-- produce/consume destination and source validity, including direct self-cycles;
-- duplicate contract and telemetry ownership.
-- train registry/document coherence in both directions.
-- journey continuation closure across reachable interlocking routes.
-
-The current source surface has 63 Python validator modules and 372 test cases.
-The remaining modules are deliberately not represented as inert Python or as a
-claim of parity. Each is admitted only after its applicability rules, clean real
-plan baseline, and fault cases are reproduced under Bun.
-
-These rules validate committed files and have no need for ATDD runtime state.
-
-## Not a package concern
-
-Do not port these into this package without a separate product decision:
-
-- interactive `atdd plan` sessions, ratify/author state, and generated issue bodies;
-- GitHub, local-store, coach, and runtime integrations;
-- ATDD substrate admission, rule binding, dispositions, or suppressions.
-
-They are orchestration capabilities, not Bun repository enforcement.
-
-## Parity requirement
-
-The current Python planner contains 197 convention nodes, 18 schemas, and 78 files
-under its validators surface. A TypeScript port is accepted only when each selected
-validator has a clean fixture, a fault fixture, and a Bun test proving both outcomes.