@wildo-ai/framework-knowledge 1.1.15 → 1.1.16

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (53) hide show
  1. package/dist/claude-marketplace/.claude-plugin/marketplace.json +1 -1
  2. package/dist/claude-marketplace/plugins/wildo/.claude-plugin/plugin.json +1 -1
  3. package/dist/claude-marketplace/plugins/wildo/references/creation-state.md +4 -1
  4. package/dist/esm/framework-knowledge.definitions.d.ts +1 -1
  5. package/dist/esm/framework-knowledge.definitions.d.ts.map +1 -1
  6. package/dist/esm/framework-knowledge.definitions.js +4 -0
  7. package/dist/esm/framework-knowledge.definitions.js.map +1 -1
  8. package/dist/esm/playbooks/bottom_up.build/playbook.definition.d.ts.map +1 -1
  9. package/dist/esm/playbooks/bottom_up.build/playbook.definition.js +6 -4
  10. package/dist/esm/playbooks/bottom_up.build/playbook.definition.js.map +1 -1
  11. package/dist/knowledge/assurance-authority-bases/wildo-safe-baseline-v1/authority-basis.json +1 -1
  12. package/dist/knowledge/assurance-authority-bases/wildo-safe-baseline-v1/external-framework-mapping.json +1 -1
  13. package/dist/knowledge/manifest.json +7 -7
  14. package/dist/knowledge/playbooks/bottom_up.build/method.md +10 -8
  15. package/dist/knowledge/playbooks/bottom_up.build/playbook.json +1 -1
  16. package/dist/knowledge/references/backend.inbound-handlers.definition.md +2 -1
  17. package/dist/knowledge/references/example.electronic-signature.engagement-letter-tool.md +54 -0
  18. package/dist/knowledge/references/example.module.relationships.discriminator.md +7 -0
  19. package/dist/knowledge/references/saas.backend.flows-actors.decision-notice-handler.md +7 -0
  20. package/dist/knowledge/references/saas.backend.flows-actors.function-tool.md +5 -0
  21. package/dist/knowledge/references/saas.backend.flows-actors.present-records-tool.md +5 -2
  22. package/dist/knowledge/references/saas.frontend.composite-view.authoring.md +19 -0
  23. package/dist/knowledge/references/saas.frontend.settings-hub.engine-destinations.md +21 -0
  24. package/dist/knowledge/references/saas.models.flows-actors.decision-card-wording.md +9 -0
  25. package/dist/knowledge/references/saas.models.flows.run-state.md +9 -0
  26. package/dist/knowledge/registries/assurance-authority-bases.json +1 -1
  27. package/dist/knowledge/registries/framework-topics.json +11 -1
  28. package/dist/knowledge/registries/playbooks.json +1 -1
  29. package/dist/knowledge/registries/source-tags.json +1019 -1002
  30. package/dist/knowledge/skills/application-roles-authoring/SKILL.md +20 -4
  31. package/dist/knowledge/skills/config-app-shell/SKILL.md +4 -0
  32. package/dist/knowledge/skills/config-saas/references/framework-auditable-event-catalog.md +2 -0
  33. package/dist/knowledge/skills/electronic-signature-deliverables/SKILL.md +58 -15
  34. package/dist/knowledge/skills/electronic-signature-deliverables/references/signing-inside-the-application.md +1 -1
  35. package/dist/knowledge/skills/electronic-signature-deliverables/references/what-makes-a-request-signed.md +32 -5
  36. package/dist/knowledge/skills/flows-actors-chat-assistant/SKILL.md +5 -4
  37. package/dist/knowledge/skills/flows-actors-chat-assistant/references/framework-flows-actors-tool-api.md +5 -0
  38. package/dist/knowledge/skills/flows-actors-chat-assistant/references/framework-flows-actors-view-api.md +15 -0
  39. package/dist/knowledge/skills/flows-actors-chat-assistant/references/framework-present-records-tool-api.md +5 -2
  40. package/dist/knowledge/skills/flows-actors-chat-assistant/references/framework-remote-a2a-agent-declaration-api.md +55 -17
  41. package/dist/knowledge/skills/flows-actors-declared-flow/references/framework-start-flow-api.md +9 -0
  42. package/dist/knowledge/skills/human-decision-notices/SKILL.md +5 -1
  43. package/dist/knowledge/skills/human-decision-notices/references/framework-decision-card-wording-api.md +9 -0
  44. package/dist/knowledge/skills/human-decision-notices/references/framework-decision-notice-handler-api.md +7 -0
  45. package/dist/knowledge/skills/inbound-channels/references/framework-inbound-handler-api.md +2 -1
  46. package/dist/knowledge/skills/module-relationships/SKILL.md +7 -0
  47. package/dist/knowledge/skills/provider-backend-package/SKILL.md +19 -2
  48. package/dist/knowledge/skills/settings-placement-authoring/references/framework-settings-destinations-catalog.md +21 -0
  49. package/dist/knowledge/skills/views-composite-authoring/SKILL.md +5 -0
  50. package/dist/knowledge/skills/views-composite-authoring/references/framework-composite-view-contracts-api.md +19 -0
  51. package/dist/knowledge/topic-index.json +104 -70
  52. package/dist/tsconfig.build.tsbuildinfo +1 -1
  53. package/package.json +4 -4
@@ -1 +1 @@
1
- {"version":3,"file":"playbook.definition.d.ts","sourceRoot":"","sources":["../../../../src/playbooks/bottom_up.build/playbook.definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,EAC9B,0BAA0B,EAC1B,0BAA0B,EAC3B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAEnB,MAAM,oDAAoD,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqI9B,CAAC"}
1
+ {"version":3,"file":"playbook.definition.d.ts","sourceRoot":"","sources":["../../../../src/playbooks/bottom_up.build/playbook.definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,EAC9B,0BAA0B,EAC1B,0BAA0B,EAC3B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EACL,wBAAwB,EACxB,kBAAkB,EAEnB,MAAM,oDAAoD,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuI9B,CAAC"}
@@ -151,12 +151,14 @@ export const playbookDefinition = {
151
151
  'bottom_up.build-dispatch',
152
152
  'bottom_up.build-decompose',
153
153
  /*
154
- * The STAFFING step, admitted for one reason: a build task can make an expert's charter stale. The design-system
155
- * task changes the design system the art director's and the design-system guardian's charters read, and the next
156
- * generation step that seats them (the logo panel) is refused until they are derived again (#3244). Before this
154
+ * The STAFFING step, admitted for one reason: an expert's charter can go stale during the build, and the next
155
+ * generation step that seats it (the logo panel) is refused until it is derived again (#3244). Since #4022 the
156
+ * build's own writes (the design system, the accepted mark) no longer age a charter while the build is unfinished,
157
+ * so what still holds a step is a definition input moving mid-build (the brand, the vision). Before this
157
158
  * admission the refusal ended the lane and the build sat idle while the root ran other lanes (reference run
158
159
  * 42218788356: 32 of 98 tasks, 40 idle minutes). Now the wave holds that step and keeps filling, and the dispatch
159
- * child runs this staffing step itself after its wave (`staffingRepair`). Admitted so the lane's write scope
160
+ * child starts this staffing step itself the moment the step is held, beside the wave (`staffingRepair`, #4022),
161
+ * and the lane does not settle while it runs. Admitted so the lane's write scope
160
162
  * claims the charters: the conception lane admits it too, so the two lanes never share a root round and never
161
163
  * derive a charter at the same time.
162
164
  */
@@ -1 +1 @@
1
- {"version":3,"file":"playbook.definition.js","sourceRoot":"","sources":["../../../../src/playbooks/bottom_up.build/playbook.definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,EAC9B,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EACL,wBAAwB,EACxB,kBAAkB,GAEnB,MAAM,oDAAoD,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,GAAG,EAAE,iBAAiB;IACtB,OAAO,EAAE,OAAO;IAChB,KAAK,EAAE,kBAAkB,CAAC,SAAS;IACnC,MAAM,EACJ,+6CAA+6C;IACj7C,aAAa,EAAE;QACb,EAAE,IAAI,EAAE,0BAA0B,CAAC,cAAc,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE;QACxF,EAAE,IAAI,EAAE,0BAA0B,CAAC,cAAc,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,gBAAgB,EAAE,EAAE;KAC5F;IACD,kGAAkG;IAClG,6DAA6D;IAC7D,MAAM,EAAE;QACN,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,wBAAwB,CAAC,GAAG,EAAE;QAC/D,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,wBAAwB,CAAC,GAAG,EAAE;QAClE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,wBAAwB,CAAC,GAAG,EAAE;KAC/D;IACD,kGAAkG;IAClG,iFAAiF;IACjF,OAAO,EAAE,EAAE;IACX;;;;OAIG;IACH,WAAW,EAAE;QACX;YACE,GAAG,EAAE,iCAAiC;YACtC,YAAY,EAAE,sGAAsG;SACrH;KACF;IACD,MAAM,EAAE;QACN,SAAS,EAAE,EAAE;QACb,YAAY,EAAE;YACZ;;;eAGG;YACH,MAAM,EAAE;gBACN,gGAAgG;gBAChG,gFAAgF;gBAChF,4BAA4B;gBAC5B,2BAA2B;gBAC3B;;;;;;;;;;;;mBAYG;gBACH,uBAAuB;gBACvB,0BAA0B;gBAC1B,2BAA2B;gBAC3B;;;;;;;;;mBASG;gBACH,0BAA0B;aAC3B;YACD;;;;;;eAMG;YACH;;;;;;;eAOG;YACH,WAAW,EAAE,2BAA2B;YACxC,iBAAiB,EAAE,EAAE;YACrB,iGAAiG;YACjG,gGAAgG;YAChG,yDAAyD;YACzD,wBAAwB,EAAE,CAAC;YAC3B;;;;;eAKG;YACH,iBAAiB,EAAE,UAAU;YAC7B;;;;;eAKG;YACH,eAAe,EAAE;gBACf;oBACE,aAAa,EAAE,2BAA2B;oBAC1C,YAAY,EAAE,wEAAwE;oBACtF,QAAQ,EAAE,CAAC,8BAA8B,CAAC,GAAG,CAAC;oBAC9C,MAAM,EAAE,CAAC,2BAA2B,CAAC;iBACtC;gBACD;oBACE,aAAa,EAAE,2BAA2B;oBAC1C,YAAY,EAAE,iEAAiE;oBAC/E,QAAQ,EAAE,CAAC,8BAA8B,CAAC,GAAG,CAAC;oBAC9C,MAAM,EAAE,CAAC,2BAA2B,CAAC;iBACtC;aACF;SACF;KACF;IACD;;;;;;OAMG;IACH,QAAQ,EAAE,2BAA2B,CAAC,cAAc;IACpD,MAAM,EAAE,EAAE;IACV,SAAS,EAAE,0BAA0B,CAAC,aAAa;CAGpD,CAAC","sourcesContent":["import {\n MetaWorkflow_ApprovalPolicy,\n MetaWorkflow_EvaluationVerdict,\n MetaWorkflow_FailurePolicy,\n MetaWorkflow_PredicateKind,\n} from '@wildo-ai/saas-models/meta-workflows';\nimport {\n MetaWorkflow_InputRender,\n MetaWorkflow_Phase,\n type MetaWorkflowPlaybookAuthoring,\n} from '@wildo-ai/saas-specifications/application-creation';\n\n/**\n * The BUILD LANE — from an accepted conception to a built, verified application and its maturity\n * reading (#1501, epic #1506).\n *\n * Until this existed `build-decompose`, `build-dispatch` and `assemble-verify` were driven by hand or\n * by `dispatch_next`: a task that could not land was re-offered until the loop guard stopped it, a\n * coherence GAP found after the build had no way back to conception, and the lane ended on four\n * typechecks with no reading of what was built against what was required. This lane runs the three\n * as one choreography — decompose, then dispatch until the plan is exhausted, then assemble — and it\n * will end on the maturity reading (#1496): a stage against the requirements, never a \"done\".\n *\n * ## The lane's OWN gate is the conception lane's output\n *\n * READINESS on the placement plan, which is the last family the conception lane lands and the one\n * the decomposer only EXPECTS on its own (`artifact_expected`, so a standalone decompose may run\n * without it — which is how an application came to have no navigation, #1265 R-6). Gating the lane\n * at READINESS is what makes \"the decomposer cannot start before placement has landed\" true for a\n * build driven through the lane: the leaf keeps its own sequencing gate and its own explicit-run\n * door, and the lane will not open until placement is on record. The domain plan is declared for the\n * same reason, and both are declared as inputs (audit rule 24).\n *\n * ## The dispatch LOOP is the child being re-offered, on purpose\n *\n * `build-dispatch` is a `CODING_AGENT` step: one run dispatches a WAVE of ready tasks — up to the\n * application's build parallelism at once, 5 by default, one when it is set to 1 (#1528) — each a coding\n * run or a companion-owned generation step (labels, logo, emails, seeds) routed by the task's own target\n * kind, waits for them, and reports. It lands no family, so the runtime never marks it delivered and\n * offers it again every round: that IS the loop. The plan's readiness is re-derived from git each\n * time, so a task accepted between two rounds unblocks its dependents without anyone re-planning.\n *\n * ## How the lane SEES its own work, and where it ends\n *\n * Both halves were measured missing on this lane's first live run and both are now built (#1501):\n *\n * - **A dispatch child reports what it did**, as a step value under `dispatch:<ref>` — the task, its\n * kind, how its coding run settled, and how much of the plan is left. Before that a child which\n * lands no family returned nothing into the run's scope, so the round history carried the objective\n * and no outcome: over twenty live rounds the selector narrated task names it could not have seen\n * and finally instructed the child to \"inspect the recorded D4 outcome for the immediately preceding\n * dispatch\" — the composite asking to be told what it should have been handed.\n * - **An exhausted plan withholds dispatch** rather than failing it. `BUILD_PLAN_EXHAUSTED` is the\n * twin of `NOTHING_TO_DECOMPOSE` one step down the same plan, and READINESS where that one is\n * SEQUENCING: re-decomposing a finished plan succeeds, dispatching one cannot, and only READINESS\n * ends the loop inside an explicitly-run lane, where sequencing is bypassed. So the round that\n * used to re-offer a dispatch that threw now offers `assemble-verify`, and the lane ends there.\n * - **A plan whose every ready task is stuck withholds dispatch too.** `BUILD_PLAN_BLOCKED_ON_STUCK_TASKS`\n * is exhaustion's twin for \"tasks remain, and none that is ready can run\": the dispatcher refuses\n * before starting one, so the lane stops offering it and says which tasks hold it, instead of\n * failing a dispatch every round (#1547).\n *\n * What is still a report rather than a route: a task that cannot land (parked on a question, or\n * refused) re-opens `bottom_up.build-decompose` in refine mode only once a verdict routes (#1498),\n * and that declaration belongs on a revise child rather than on this lane.\n *\n * ## `build-scale` is admitted, and it runs the same wave as dispatch\n *\n * Admitted in c6a1a235 (#1273) because nothing else could ever reach it. `build-scale` declares the\n * same executor as `build-dispatch`, so it runs through the same CODING_AGENT branch: with a build\n * parallelism above one, both start the same rolling wave (#1528); at one, both dispatch one task.\n * Its method describes that wave from the scheduling side. The lane's method tells the selector to\n * prefer `build-dispatch`, so the two names do not compete for one act (#2207).\n *\n * ## The lane ENDS on the maturity reading (#1496, admitted 2026-09-22 when its leaf landed)\n *\n * `bottom_up.assemble-verify` answers whether what was built ASSEMBLES — four typechecks and a\n * migration probe, its own method saying it \"does not boot the application, run its test suite\".\n * `bottom_up.maturity-reading` answers the question that makes the lane worth running: which of the\n * application's own requirements are addressed, by what evidence, and what STAGE that puts it at.\n *\n * Paul, 2026-09-22: *\"there are no 'Done' for an app, there are a measurement face to requirements,\n * with some stage … this measurement should be evolutive.\"* So the lane's closing decision is read\n * against the reading, and a run that stops short of it has not finished — which is why it is listed\n * FIRST in `admits`, where the trap check puts the closing move.\n *\n * **Only this lane admits it, deliberately.** Its own gate is `artifact_exists: requirements`, so it\n * could be offered far earlier — and a reading of an application nobody has conceived says \"nothing is\n * addressed\", which is true and worth nothing. A second admitter would also let one root run land the\n * same reading twice from the same inputs, because a nested lane's delivered set is its own. The root's\n * ending is the boundary decision READ AGAINST whatever reading is on record, not a second reading.\n *\n * The surface lanes' work (UX #1493, website #1492, documentation #1494, integration #1495) feeds the\n * same task graph through DECOMPOSITION rather than through new children here — their plans are the\n * conception lane's, and the decomposer declares all of them as inputs.\n *\n * ## Loop-back — declared when the mechanism exists\n *\n * | signal | re-opens | how, once it can |\n * |---|---|---|\n * | a task that cannot land (parked, refused, failed twice) | `bottom_up.build-decompose` in refine mode | verdict routing (#1498) on the dispatch report |\n * | a coherence GAP naming a module or relationship | `bottom_up.domain-plan`, through the root | the root routes it to the conception lane (#1503, after #1497) |\n * | a domain plan or placement newer than the landed build plan | `bottom_up.build-decompose` | ALREADY WORKS — the decompose completion gate re-opens on any newer upstream commit |\n */\nexport const playbookDefinition = {\n ref: 'bottom_up.build',\n version: '0.2.0',\n phase: MetaWorkflow_Phase.BOTTOM_UP,\n intent:\n 'Drive the BUILD of the application as one lane: decompose the accepted conception into a build plan, dispatch the plan\\'s ready tasks in parallel waves — up to the application\\'s build parallelism at once (5 by default; 1 means one at a time), coding runs and the companion\\'s own generation steps alike — until every task has landed, then assemble and verify the built application, and read its maturity against the requirements it was asked to satisfy. An umbrella: it authors nothing itself; every child declares what it needs and the runtime recomputes what may run after each round. The build plan is decomposed ONCE unless its inputs have moved since it landed (the decomposer\\'s own gate says so). Dispatch is one wave per run (the parallelism is inside it, so select ONE child per round) and lands no family, so it is offered every round: keep selecting it while the plan has tasks left, with each round\\'s objective naming what the previous round\\'s wave dispatched and how each run came out. Prefer build-dispatch to build-scale: both start the same wave. When dispatch reports the plan exhausted, select assemble-verify, and then the maturity reading. STOP on the reading: it is what this lane ends on, and it names a STAGE rather than a completion. Stop early only when dispatch reports a task that cannot land twice, or a parked question waits on the creator — say which. A parked coding question waits for the creator; run everything else.',\n preconditions: [\n { kind: MetaWorkflow_PredicateKind.ARTIFACT_VALID, selector: { family: 'domain-plan' } },\n { kind: MetaWorkflow_PredicateKind.ARTIFACT_VALID, selector: { family: 'placement-plan' } },\n ],\n // For the SELECTOR: the plans as maps of what exists; the build plan's tasks by ref, so a round's\n // objective can name the task the previous round dispatched.\n inputs: [\n { family: 'domain-plan', render: MetaWorkflow_InputRender.MAP },\n { family: 'placement-plan', render: MetaWorkflow_InputRender.MAP },\n { family: 'build-plan', render: MetaWorkflow_InputRender.MAP },\n ],\n // Nothing — the lane's write scope is resolved transitively through `admits`: the build plan, and\n // the application WORKSPACE, which a dispatch writes and a human commit accepts.\n outputs: [],\n /*\n * The one value this lane hands up (#1638): the decomposer's verdict, so the root can send the run back\n * to CONCEPTION when the plan cannot be right because what it rests on is wrong (the decomposer's\n * `conception-buildable` criterion). Its own coverage GAPs stay in the lane and re-open the decomposer.\n */\n stepOutputs: [\n {\n ref: 'judge:bottom_up.build-decompose',\n condensation: 'The decomposer verdict on the build plan: overall and per criterion, including conception-buildable.',\n },\n ],\n method: {\n skillRefs: [],\n choreography: {\n /*\n * UNORDERED. Listed closing-move-first on purpose, the umbrellas' own trap check: read as a\n * sequence this would verify an application nobody had built, and fail loudly.\n */\n admits: [\n // The lane's ENDING, and the reason it is not `assemble-verify`: assembly asks whether what was\n // built compiles, the reading asks what it is worth against what was asked for.\n 'bottom_up.maturity-reading',\n 'bottom_up.assemble-verify',\n /*\n * SCALE, and the reason it is listed beside dispatch rather than instead of it.\n *\n * It was admitted by NOTHING until 2026-09-23 (#1273) — authored, compiled, shipped in the\n * catalog and reported `eligible: true` by the board, while no lane could ever reach it. A\n * playbook no composite admits is unreachable from any journey, and nothing reports that:\n * the eligibility board answers about the playbook, never about whether anyone can dispatch\n * it. Measured on the first end-to-end run, where it cost the build lane its parallelism.\n *\n * It does not replace `build-dispatch`: both start the same wave, and the method prefers\n * dispatch. Scale stays admitted because its method is where the wave's scheduling — the\n * ready-set, the width, the shared-worktree repair — is described for a selector that asks.\n */\n 'bottom_up.build-scale',\n 'bottom_up.build-dispatch',\n 'bottom_up.build-decompose',\n /*\n * The STAFFING step, admitted for one reason: a build task can make an expert's charter stale. The design-system\n * task changes the design system the art director's and the design-system guardian's charters read, and the next\n * generation step that seats them (the logo panel) is refused until they are derived again (#3244). Before this\n * admission the refusal ended the lane and the build sat idle while the root ran other lanes (reference run\n * 42218788356: 32 of 98 tasks, 40 idle minutes). Now the wave holds that step and keeps filling, and the dispatch\n * child runs this staffing step itself after its wave (`staffingRepair`). Admitted so the lane's write scope\n * claims the charters: the conception lane admits it too, so the two lanes never share a root round and never\n * derive a charter at the same time.\n */\n 'top_down.expert-personas',\n ],\n /*\n * The schema's ceiling, and for this lane it is the BINDING bound: one round per wave (per task\n * at a build parallelism of 1), and a 42-task plan (Wonder CRM's, measured) can need more rounds\n * than any composite may run. So a full build is SEVERAL runs of this lane, each resuming where readiness now stands —\n * which is correct by construction (the plan's state is git, not the run) and is the reason the\n * lane is re-runnable at all. A breaker, not a budget.\n */\n /*\n * No run of this lane ends without asking whether the application ASSEMBLES (#2228). On app-creation-test-004 the\n * lane reached 91 of 93 tasks and stopped, assemble-verify was never selected, and the website that did not build\n * went unreported. When the selector stops first — the plan exhausted, a task that cannot land, a question waiting\n * on the creator — the runtime runs assemble-verify; a run that cannot reach it (no build plan yet) ends recorded\n * as not concluded. The cost is deliberate: a paused build also pays one assembly pass, because a pause is where a\n * person reads the state, and the state without this answer is the misleading one.\n */\n closingMove: 'bottom_up.assemble-verify',\n maximumIterations: 20,\n // One lane per round because the parallelism is INSIDE the dispatch child: its wave already runs\n // up to the build parallelism of tasks at once (#1528). A second lane would start a second wave\n // beside it and double the width the person set (#2207).\n maximumLanesPerIteration: 1,\n /*\n * Six hours. A coding run measured ~15 minutes and ~$26 (#1454); twenty rounds of dispatch at\n * that figure is five hours, and a decomposition or an assembly is minutes beside it. Far longer\n * than the companion's HTTP ceiling (30 min): submit with `async: true` and read the outcome\n * from `/playbooks/runs`. Literal: the evaluator computes no expressions.\n */\n maximumDurationMs: 21_600_000,\n /*\n * The loop back to DECOMPOSITION (#1501): a plan its own judge finds does not cover the domain\n * plan's modules, resources or relationships is re-decomposed before anything is built on it.\n * The decomposer re-opens itself, in refine mode per the method, keeping the refs of what landed.\n * The loop back to CONCEPTION is the ROOT's, from this lane's exported verdict (#1638).\n */\n reopenOnVerdict: [\n {\n whenVerdictOf: 'bottom_up.build-decompose',\n criterionRef: 'application-creation:criterion/build-plan-module-and-resource-coverage',\n verdicts: [MetaWorkflow_EvaluationVerdict.GAP],\n reopen: ['bottom_up.build-decompose'],\n },\n {\n whenVerdictOf: 'bottom_up.build-decompose',\n criterionRef: 'application-creation:criterion/build-plan-relationship-coverage',\n verdicts: [MetaWorkflow_EvaluationVerdict.GAP],\n reopen: ['bottom_up.build-decompose'],\n },\n ],\n },\n },\n /*\n * The lane's closing decision — read the maturity, accept the stage or send the build back.\n * LIVE since #111 landed: the runtime derives this lane's boundary from the field and the companion\n * projects one `approve_result` decision over the paths the lane kept — which for this lane is the\n * application WORKSPACE its dispatches wrote, not a specifications family. The maturity reading the\n * decision should be read against is still #1496.\n */\n approval: MetaWorkflow_ApprovalPolicy.APPROVE_RESULT,\n budget: {},\n onFailure: MetaWorkflow_FailurePolicy.KEEP_AND_FLAG,\n} satisfies Omit<MetaWorkflowPlaybookAuthoring, 'method'> & {\n method: Omit<NonNullable<MetaWorkflowPlaybookAuthoring['method']>, 'guidance'>;\n};\n"]}
1
+ {"version":3,"file":"playbook.definition.js","sourceRoot":"","sources":["../../../../src/playbooks/bottom_up.build/playbook.definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,EAC9B,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EACL,wBAAwB,EACxB,kBAAkB,GAEnB,MAAM,oDAAoD,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,GAAG,EAAE,iBAAiB;IACtB,OAAO,EAAE,OAAO;IAChB,KAAK,EAAE,kBAAkB,CAAC,SAAS;IACnC,MAAM,EACJ,+6CAA+6C;IACj7C,aAAa,EAAE;QACb,EAAE,IAAI,EAAE,0BAA0B,CAAC,cAAc,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE;QACxF,EAAE,IAAI,EAAE,0BAA0B,CAAC,cAAc,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,gBAAgB,EAAE,EAAE;KAC5F;IACD,kGAAkG;IAClG,6DAA6D;IAC7D,MAAM,EAAE;QACN,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,wBAAwB,CAAC,GAAG,EAAE;QAC/D,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,wBAAwB,CAAC,GAAG,EAAE;QAClE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,wBAAwB,CAAC,GAAG,EAAE;KAC/D;IACD,kGAAkG;IAClG,iFAAiF;IACjF,OAAO,EAAE,EAAE;IACX;;;;OAIG;IACH,WAAW,EAAE;QACX;YACE,GAAG,EAAE,iCAAiC;YACtC,YAAY,EAAE,sGAAsG;SACrH;KACF;IACD,MAAM,EAAE;QACN,SAAS,EAAE,EAAE;QACb,YAAY,EAAE;YACZ;;;eAGG;YACH,MAAM,EAAE;gBACN,gGAAgG;gBAChG,gFAAgF;gBAChF,4BAA4B;gBAC5B,2BAA2B;gBAC3B;;;;;;;;;;;;mBAYG;gBACH,uBAAuB;gBACvB,0BAA0B;gBAC1B,2BAA2B;gBAC3B;;;;;;;;;;;mBAWG;gBACH,0BAA0B;aAC3B;YACD;;;;;;eAMG;YACH;;;;;;;eAOG;YACH,WAAW,EAAE,2BAA2B;YACxC,iBAAiB,EAAE,EAAE;YACrB,iGAAiG;YACjG,gGAAgG;YAChG,yDAAyD;YACzD,wBAAwB,EAAE,CAAC;YAC3B;;;;;eAKG;YACH,iBAAiB,EAAE,UAAU;YAC7B;;;;;eAKG;YACH,eAAe,EAAE;gBACf;oBACE,aAAa,EAAE,2BAA2B;oBAC1C,YAAY,EAAE,wEAAwE;oBACtF,QAAQ,EAAE,CAAC,8BAA8B,CAAC,GAAG,CAAC;oBAC9C,MAAM,EAAE,CAAC,2BAA2B,CAAC;iBACtC;gBACD;oBACE,aAAa,EAAE,2BAA2B;oBAC1C,YAAY,EAAE,iEAAiE;oBAC/E,QAAQ,EAAE,CAAC,8BAA8B,CAAC,GAAG,CAAC;oBAC9C,MAAM,EAAE,CAAC,2BAA2B,CAAC;iBACtC;aACF;SACF;KACF;IACD;;;;;;OAMG;IACH,QAAQ,EAAE,2BAA2B,CAAC,cAAc;IACpD,MAAM,EAAE,EAAE;IACV,SAAS,EAAE,0BAA0B,CAAC,aAAa;CAGpD,CAAC","sourcesContent":["import {\n MetaWorkflow_ApprovalPolicy,\n MetaWorkflow_EvaluationVerdict,\n MetaWorkflow_FailurePolicy,\n MetaWorkflow_PredicateKind,\n} from '@wildo-ai/saas-models/meta-workflows';\nimport {\n MetaWorkflow_InputRender,\n MetaWorkflow_Phase,\n type MetaWorkflowPlaybookAuthoring,\n} from '@wildo-ai/saas-specifications/application-creation';\n\n/**\n * The BUILD LANE — from an accepted conception to a built, verified application and its maturity\n * reading (#1501, epic #1506).\n *\n * Until this existed `build-decompose`, `build-dispatch` and `assemble-verify` were driven by hand or\n * by `dispatch_next`: a task that could not land was re-offered until the loop guard stopped it, a\n * coherence GAP found after the build had no way back to conception, and the lane ended on four\n * typechecks with no reading of what was built against what was required. This lane runs the three\n * as one choreography — decompose, then dispatch until the plan is exhausted, then assemble — and it\n * will end on the maturity reading (#1496): a stage against the requirements, never a \"done\".\n *\n * ## The lane's OWN gate is the conception lane's output\n *\n * READINESS on the placement plan, which is the last family the conception lane lands and the one\n * the decomposer only EXPECTS on its own (`artifact_expected`, so a standalone decompose may run\n * without it — which is how an application came to have no navigation, #1265 R-6). Gating the lane\n * at READINESS is what makes \"the decomposer cannot start before placement has landed\" true for a\n * build driven through the lane: the leaf keeps its own sequencing gate and its own explicit-run\n * door, and the lane will not open until placement is on record. The domain plan is declared for the\n * same reason, and both are declared as inputs (audit rule 24).\n *\n * ## The dispatch LOOP is the child being re-offered, on purpose\n *\n * `build-dispatch` is a `CODING_AGENT` step: one run dispatches a WAVE of ready tasks — up to the\n * application's build parallelism at once, 5 by default, one when it is set to 1 (#1528) — each a coding\n * run or a companion-owned generation step (labels, logo, emails, seeds) routed by the task's own target\n * kind, waits for them, and reports. It lands no family, so the runtime never marks it delivered and\n * offers it again every round: that IS the loop. The plan's readiness is re-derived from git each\n * time, so a task accepted between two rounds unblocks its dependents without anyone re-planning.\n *\n * ## How the lane SEES its own work, and where it ends\n *\n * Both halves were measured missing on this lane's first live run and both are now built (#1501):\n *\n * - **A dispatch child reports what it did**, as a step value under `dispatch:<ref>` — the task, its\n * kind, how its coding run settled, and how much of the plan is left. Before that a child which\n * lands no family returned nothing into the run's scope, so the round history carried the objective\n * and no outcome: over twenty live rounds the selector narrated task names it could not have seen\n * and finally instructed the child to \"inspect the recorded D4 outcome for the immediately preceding\n * dispatch\" — the composite asking to be told what it should have been handed.\n * - **An exhausted plan withholds dispatch** rather than failing it. `BUILD_PLAN_EXHAUSTED` is the\n * twin of `NOTHING_TO_DECOMPOSE` one step down the same plan, and READINESS where that one is\n * SEQUENCING: re-decomposing a finished plan succeeds, dispatching one cannot, and only READINESS\n * ends the loop inside an explicitly-run lane, where sequencing is bypassed. So the round that\n * used to re-offer a dispatch that threw now offers `assemble-verify`, and the lane ends there.\n * - **A plan whose every ready task is stuck withholds dispatch too.** `BUILD_PLAN_BLOCKED_ON_STUCK_TASKS`\n * is exhaustion's twin for \"tasks remain, and none that is ready can run\": the dispatcher refuses\n * before starting one, so the lane stops offering it and says which tasks hold it, instead of\n * failing a dispatch every round (#1547).\n *\n * What is still a report rather than a route: a task that cannot land (parked on a question, or\n * refused) re-opens `bottom_up.build-decompose` in refine mode only once a verdict routes (#1498),\n * and that declaration belongs on a revise child rather than on this lane.\n *\n * ## `build-scale` is admitted, and it runs the same wave as dispatch\n *\n * Admitted in c6a1a235 (#1273) because nothing else could ever reach it. `build-scale` declares the\n * same executor as `build-dispatch`, so it runs through the same CODING_AGENT branch: with a build\n * parallelism above one, both start the same rolling wave (#1528); at one, both dispatch one task.\n * Its method describes that wave from the scheduling side. The lane's method tells the selector to\n * prefer `build-dispatch`, so the two names do not compete for one act (#2207).\n *\n * ## The lane ENDS on the maturity reading (#1496, admitted 2026-09-22 when its leaf landed)\n *\n * `bottom_up.assemble-verify` answers whether what was built ASSEMBLES — four typechecks and a\n * migration probe, its own method saying it \"does not boot the application, run its test suite\".\n * `bottom_up.maturity-reading` answers the question that makes the lane worth running: which of the\n * application's own requirements are addressed, by what evidence, and what STAGE that puts it at.\n *\n * Paul, 2026-09-22: *\"there are no 'Done' for an app, there are a measurement face to requirements,\n * with some stage … this measurement should be evolutive.\"* So the lane's closing decision is read\n * against the reading, and a run that stops short of it has not finished — which is why it is listed\n * FIRST in `admits`, where the trap check puts the closing move.\n *\n * **Only this lane admits it, deliberately.** Its own gate is `artifact_exists: requirements`, so it\n * could be offered far earlier — and a reading of an application nobody has conceived says \"nothing is\n * addressed\", which is true and worth nothing. A second admitter would also let one root run land the\n * same reading twice from the same inputs, because a nested lane's delivered set is its own. The root's\n * ending is the boundary decision READ AGAINST whatever reading is on record, not a second reading.\n *\n * The surface lanes' work (UX #1493, website #1492, documentation #1494, integration #1495) feeds the\n * same task graph through DECOMPOSITION rather than through new children here — their plans are the\n * conception lane's, and the decomposer declares all of them as inputs.\n *\n * ## Loop-back — declared when the mechanism exists\n *\n * | signal | re-opens | how, once it can |\n * |---|---|---|\n * | a task that cannot land (parked, refused, failed twice) | `bottom_up.build-decompose` in refine mode | verdict routing (#1498) on the dispatch report |\n * | a coherence GAP naming a module or relationship | `bottom_up.domain-plan`, through the root | the root routes it to the conception lane (#1503, after #1497) |\n * | a domain plan or placement newer than the landed build plan | `bottom_up.build-decompose` | ALREADY WORKS — the decompose completion gate re-opens on any newer upstream commit |\n */\nexport const playbookDefinition = {\n ref: 'bottom_up.build',\n version: '0.2.0',\n phase: MetaWorkflow_Phase.BOTTOM_UP,\n intent:\n 'Drive the BUILD of the application as one lane: decompose the accepted conception into a build plan, dispatch the plan\\'s ready tasks in parallel waves — up to the application\\'s build parallelism at once (5 by default; 1 means one at a time), coding runs and the companion\\'s own generation steps alike — until every task has landed, then assemble and verify the built application, and read its maturity against the requirements it was asked to satisfy. An umbrella: it authors nothing itself; every child declares what it needs and the runtime recomputes what may run after each round. The build plan is decomposed ONCE unless its inputs have moved since it landed (the decomposer\\'s own gate says so). Dispatch is one wave per run (the parallelism is inside it, so select ONE child per round) and lands no family, so it is offered every round: keep selecting it while the plan has tasks left, with each round\\'s objective naming what the previous round\\'s wave dispatched and how each run came out. Prefer build-dispatch to build-scale: both start the same wave. When dispatch reports the plan exhausted, select assemble-verify, and then the maturity reading. STOP on the reading: it is what this lane ends on, and it names a STAGE rather than a completion. Stop early only when dispatch reports a task that cannot land twice, or a parked question waits on the creator — say which. A parked coding question waits for the creator; run everything else.',\n preconditions: [\n { kind: MetaWorkflow_PredicateKind.ARTIFACT_VALID, selector: { family: 'domain-plan' } },\n { kind: MetaWorkflow_PredicateKind.ARTIFACT_VALID, selector: { family: 'placement-plan' } },\n ],\n // For the SELECTOR: the plans as maps of what exists; the build plan's tasks by ref, so a round's\n // objective can name the task the previous round dispatched.\n inputs: [\n { family: 'domain-plan', render: MetaWorkflow_InputRender.MAP },\n { family: 'placement-plan', render: MetaWorkflow_InputRender.MAP },\n { family: 'build-plan', render: MetaWorkflow_InputRender.MAP },\n ],\n // Nothing — the lane's write scope is resolved transitively through `admits`: the build plan, and\n // the application WORKSPACE, which a dispatch writes and a human commit accepts.\n outputs: [],\n /*\n * The one value this lane hands up (#1638): the decomposer's verdict, so the root can send the run back\n * to CONCEPTION when the plan cannot be right because what it rests on is wrong (the decomposer's\n * `conception-buildable` criterion). Its own coverage GAPs stay in the lane and re-open the decomposer.\n */\n stepOutputs: [\n {\n ref: 'judge:bottom_up.build-decompose',\n condensation: 'The decomposer verdict on the build plan: overall and per criterion, including conception-buildable.',\n },\n ],\n method: {\n skillRefs: [],\n choreography: {\n /*\n * UNORDERED. Listed closing-move-first on purpose, the umbrellas' own trap check: read as a\n * sequence this would verify an application nobody had built, and fail loudly.\n */\n admits: [\n // The lane's ENDING, and the reason it is not `assemble-verify`: assembly asks whether what was\n // built compiles, the reading asks what it is worth against what was asked for.\n 'bottom_up.maturity-reading',\n 'bottom_up.assemble-verify',\n /*\n * SCALE, and the reason it is listed beside dispatch rather than instead of it.\n *\n * It was admitted by NOTHING until 2026-09-23 (#1273) — authored, compiled, shipped in the\n * catalog and reported `eligible: true` by the board, while no lane could ever reach it. A\n * playbook no composite admits is unreachable from any journey, and nothing reports that:\n * the eligibility board answers about the playbook, never about whether anyone can dispatch\n * it. Measured on the first end-to-end run, where it cost the build lane its parallelism.\n *\n * It does not replace `build-dispatch`: both start the same wave, and the method prefers\n * dispatch. Scale stays admitted because its method is where the wave's scheduling — the\n * ready-set, the width, the shared-worktree repair — is described for a selector that asks.\n */\n 'bottom_up.build-scale',\n 'bottom_up.build-dispatch',\n 'bottom_up.build-decompose',\n /*\n * The STAFFING step, admitted for one reason: an expert's charter can go stale during the build, and the next\n * generation step that seats it (the logo panel) is refused until it is derived again (#3244). Since #4022 the\n * build's own writes (the design system, the accepted mark) no longer age a charter while the build is unfinished,\n * so what still holds a step is a definition input moving mid-build (the brand, the vision). Before this\n * admission the refusal ended the lane and the build sat idle while the root ran other lanes (reference run\n * 42218788356: 32 of 98 tasks, 40 idle minutes). Now the wave holds that step and keeps filling, and the dispatch\n * child starts this staffing step itself the moment the step is held, beside the wave (`staffingRepair`, #4022),\n * and the lane does not settle while it runs. Admitted so the lane's write scope\n * claims the charters: the conception lane admits it too, so the two lanes never share a root round and never\n * derive a charter at the same time.\n */\n 'top_down.expert-personas',\n ],\n /*\n * The schema's ceiling, and for this lane it is the BINDING bound: one round per wave (per task\n * at a build parallelism of 1), and a 42-task plan (Wonder CRM's, measured) can need more rounds\n * than any composite may run. So a full build is SEVERAL runs of this lane, each resuming where readiness now stands —\n * which is correct by construction (the plan's state is git, not the run) and is the reason the\n * lane is re-runnable at all. A breaker, not a budget.\n */\n /*\n * No run of this lane ends without asking whether the application ASSEMBLES (#2228). On app-creation-test-004 the\n * lane reached 91 of 93 tasks and stopped, assemble-verify was never selected, and the website that did not build\n * went unreported. When the selector stops first — the plan exhausted, a task that cannot land, a question waiting\n * on the creator — the runtime runs assemble-verify; a run that cannot reach it (no build plan yet) ends recorded\n * as not concluded. The cost is deliberate: a paused build also pays one assembly pass, because a pause is where a\n * person reads the state, and the state without this answer is the misleading one.\n */\n closingMove: 'bottom_up.assemble-verify',\n maximumIterations: 20,\n // One lane per round because the parallelism is INSIDE the dispatch child: its wave already runs\n // up to the build parallelism of tasks at once (#1528). A second lane would start a second wave\n // beside it and double the width the person set (#2207).\n maximumLanesPerIteration: 1,\n /*\n * Six hours. A coding run measured ~15 minutes and ~$26 (#1454); twenty rounds of dispatch at\n * that figure is five hours, and a decomposition or an assembly is minutes beside it. Far longer\n * than the companion's HTTP ceiling (30 min): submit with `async: true` and read the outcome\n * from `/playbooks/runs`. Literal: the evaluator computes no expressions.\n */\n maximumDurationMs: 21_600_000,\n /*\n * The loop back to DECOMPOSITION (#1501): a plan its own judge finds does not cover the domain\n * plan's modules, resources or relationships is re-decomposed before anything is built on it.\n * The decomposer re-opens itself, in refine mode per the method, keeping the refs of what landed.\n * The loop back to CONCEPTION is the ROOT's, from this lane's exported verdict (#1638).\n */\n reopenOnVerdict: [\n {\n whenVerdictOf: 'bottom_up.build-decompose',\n criterionRef: 'application-creation:criterion/build-plan-module-and-resource-coverage',\n verdicts: [MetaWorkflow_EvaluationVerdict.GAP],\n reopen: ['bottom_up.build-decompose'],\n },\n {\n whenVerdictOf: 'bottom_up.build-decompose',\n criterionRef: 'application-creation:criterion/build-plan-relationship-coverage',\n verdicts: [MetaWorkflow_EvaluationVerdict.GAP],\n reopen: ['bottom_up.build-decompose'],\n },\n ],\n },\n },\n /*\n * The lane's closing decision — read the maturity, accept the stage or send the build back.\n * LIVE since #111 landed: the runtime derives this lane's boundary from the field and the companion\n * projects one `approve_result` decision over the paths the lane kept — which for this lane is the\n * application WORKSPACE its dispatches wrote, not a specifications family. The maturity reading the\n * decision should be read against is still #1496.\n */\n approval: MetaWorkflow_ApprovalPolicy.APPROVE_RESULT,\n budget: {},\n onFailure: MetaWorkflow_FailurePolicy.KEEP_AND_FLAG,\n} satisfies Omit<MetaWorkflowPlaybookAuthoring, 'method'> & {\n method: Omit<NonNullable<MetaWorkflowPlaybookAuthoring['method']>, 'guidance'>;\n};\n"]}