@wildo-ai/framework-knowledge 1.1.14 → 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.
- package/dist/claude-marketplace/.claude-plugin/marketplace.json +1 -1
- package/dist/claude-marketplace/plugins/wildo/.claude-plugin/plugin.json +1 -1
- package/dist/claude-marketplace/plugins/wildo/references/creation-state.md +4 -1
- package/dist/esm/framework-knowledge.definitions.d.ts +1 -1
- package/dist/esm/framework-knowledge.definitions.d.ts.map +1 -1
- package/dist/esm/framework-knowledge.definitions.js +13 -0
- package/dist/esm/framework-knowledge.definitions.js.map +1 -1
- package/dist/esm/playbooks/bottom_up.assemble-verify/playbook.definition.d.ts +1 -1
- package/dist/esm/playbooks/bottom_up.assemble-verify/playbook.definition.js +1 -1
- package/dist/esm/playbooks/bottom_up.assemble-verify/playbook.definition.js.map +1 -1
- package/dist/esm/playbooks/bottom_up.build/playbook.definition.d.ts.map +1 -1
- package/dist/esm/playbooks/bottom_up.build/playbook.definition.js +6 -4
- package/dist/esm/playbooks/bottom_up.build/playbook.definition.js.map +1 -1
- package/dist/esm/playbooks/bottom_up.integration-plan/playbook.definition.d.ts +1 -1
- package/dist/esm/playbooks/bottom_up.integration-plan/playbook.definition.js +1 -1
- package/dist/esm/playbooks/bottom_up.integration-plan/playbook.definition.js.map +1 -1
- package/dist/knowledge/assurance-authority-bases/wildo-safe-baseline-v1/authority-basis.json +1 -1
- package/dist/knowledge/assurance-authority-bases/wildo-safe-baseline-v1/external-framework-mapping.json +1 -1
- package/dist/knowledge/manifest.json +7 -7
- package/dist/knowledge/playbooks/bottom_up.assemble-verify/method.md +7 -0
- package/dist/knowledge/playbooks/bottom_up.assemble-verify/playbook.json +2 -2
- package/dist/knowledge/playbooks/bottom_up.build/method.md +10 -8
- package/dist/knowledge/playbooks/bottom_up.build/playbook.json +1 -1
- package/dist/knowledge/playbooks/bottom_up.build-decompose/method.md +27 -10
- package/dist/knowledge/playbooks/bottom_up.build-decompose/playbook.json +1 -1
- package/dist/knowledge/playbooks/bottom_up.build-dispatch/method.md +13 -9
- package/dist/knowledge/playbooks/bottom_up.build-dispatch/playbook.json +1 -1
- package/dist/knowledge/playbooks/bottom_up.integration-plan/method.md +20 -5
- package/dist/knowledge/playbooks/bottom_up.integration-plan/playbook.json +2 -2
- package/dist/knowledge/playbooks/refinement.compliance-document-candidate/method.md +4 -0
- package/dist/knowledge/playbooks/refinement.compliance-document-candidate/playbook.json +1 -1
- package/dist/knowledge/references/backend.inbound-handlers.definition.md +2 -1
- package/dist/knowledge/references/build-plan.task-graph.config.md +12 -8
- package/dist/knowledge/references/example.electronic-signature.engagement-letter-tool.md +54 -0
- package/dist/knowledge/references/example.flows-actors.autonomous-agent.reviewed-write.md +6 -2
- package/dist/knowledge/references/example.flows-actors.chat-assistant.md +13 -2
- package/dist/knowledge/references/example.inbound.email-to-todo.md +33 -2
- package/dist/knowledge/references/example.module.relationships.discriminator.md +14 -1
- package/dist/knowledge/references/external-connectors.frontend-provider-consent-classification.md +2 -0
- package/dist/knowledge/references/integration-plan.config.md +78 -8
- package/dist/knowledge/references/platform.config.environment.deployment.md +27 -4
- package/dist/knowledge/references/saas.backend.domain-module.md +15 -0
- package/dist/knowledge/references/saas.backend.flows-actors.a2a-agent-card.md +43 -11
- package/dist/knowledge/references/saas.backend.flows-actors.a2a-task-surface.md +17 -11
- package/dist/knowledge/references/saas.backend.flows-actors.decision-notice-handler.md +7 -0
- package/dist/knowledge/references/saas.backend.flows-actors.function-tool.md +16 -0
- package/dist/knowledge/references/saas.backend.flows-actors.present-records-tool.md +5 -2
- package/dist/knowledge/references/saas.frontend.composite-view.authoring.md +19 -0
- package/dist/knowledge/references/saas.frontend.electronic-signatures.embedded-signing-frame.md +46 -0
- package/dist/knowledge/references/saas.frontend.settings-hub.engine-destinations.md +21 -0
- package/dist/knowledge/references/saas.models.flows-actors.agent-definition.md +24 -33
- package/dist/knowledge/references/saas.models.flows-actors.decision-card-wording.md +9 -0
- package/dist/knowledge/references/saas.models.flows-actors.mcp-server-declaration.md +63 -0
- package/dist/knowledge/references/saas.models.flows-actors.outbound-credential.md +61 -0
- package/dist/knowledge/references/saas.models.flows-actors.remote-agent-declaration.md +56 -0
- package/dist/knowledge/references/saas.models.flows.run-state.md +9 -0
- package/dist/knowledge/references/saas.models.http-api-binding.md +51 -0
- package/dist/knowledge/references/saas.models.privacy.provider-capability-disclosure.md +7 -0
- package/dist/knowledge/references/saas.models.provider-capabilities.md +11 -0
- package/dist/knowledge/references/saas.models.system-of-record-error-codes.md +30 -0
- package/dist/knowledge/references/saas.rag.retrieval-scores.md +4 -2
- package/dist/knowledge/registries/assurance-authority-bases.json +1 -1
- package/dist/knowledge/registries/framework-topics.json +55 -1
- package/dist/knowledge/registries/playbooks.json +2 -2
- package/dist/knowledge/registries/source-tags.json +1127 -1042
- package/dist/knowledge/skills/INDEX.md +2 -2
- package/dist/knowledge/skills/application-roles-authoring/SKILL.md +20 -4
- package/dist/knowledge/skills/backend-addon-wiring/SKILL.md +4 -1
- package/dist/knowledge/skills/backend-addon-wiring/references/framework-backend-bootstrap-api.md +15 -0
- package/dist/knowledge/skills/backend-custom-operation/SKILL.md +3 -1
- package/dist/knowledge/skills/compliance-document-authoring/references/document-composition-privacy-notice.md +4 -0
- package/dist/knowledge/skills/compliance-document-authoring/references/framework-recipient-disclosures.md +7 -0
- package/dist/knowledge/skills/config-app-shell/SKILL.md +4 -0
- package/dist/knowledge/skills/config-saas/references/framework-auditable-event-catalog.md +3 -0
- package/dist/knowledge/skills/config-saas/references/framework-provider-capabilities-api.md +11 -0
- package/dist/knowledge/skills/electronic-signature-deliverables/SKILL.md +69 -19
- package/dist/knowledge/skills/electronic-signature-deliverables/references/signing-inside-the-application.md +113 -0
- package/dist/knowledge/skills/electronic-signature-deliverables/references/what-makes-a-request-signed.md +32 -5
- package/dist/knowledge/skills/email-add-template/SKILL.md +3 -2
- package/dist/knowledge/skills/email-add-template/references/email-artifact-paths.md +8 -4
- package/dist/knowledge/skills/email-definition-wiring/SKILL.md +1 -1
- package/dist/knowledge/skills/flows-actors-a2a-exposure/SKILL.md +29 -7
- package/dist/knowledge/skills/flows-actors-a2a-exposure/references/framework-flows-actors-a2a-contract.md +66 -26
- package/dist/knowledge/skills/flows-actors-autonomous-agents/SKILL.md +6 -2
- package/dist/knowledge/skills/flows-actors-chat-assistant/SKILL.md +35 -3
- package/dist/knowledge/skills/flows-actors-chat-assistant/examples/todo-assistant.example.md +13 -2
- package/dist/knowledge/skills/flows-actors-chat-assistant/references/framework-flows-actors-tool-api.md +16 -0
- package/dist/knowledge/skills/flows-actors-chat-assistant/references/framework-flows-actors-view-api.md +30 -0
- package/dist/knowledge/skills/flows-actors-chat-assistant/references/framework-mcp-server-declaration-api.md +139 -0
- package/dist/knowledge/skills/flows-actors-chat-assistant/references/framework-present-records-tool-api.md +5 -2
- package/dist/knowledge/skills/flows-actors-chat-assistant/references/framework-remote-a2a-agent-declaration-api.md +207 -0
- package/dist/knowledge/skills/flows-actors-declared-flow/references/framework-start-flow-api.md +9 -0
- package/dist/knowledge/skills/flows-actors-llm-agent-invocation/references/framework-llm-agent-definition-api.md +24 -33
- package/dist/knowledge/skills/human-decision-notices/SKILL.md +5 -1
- package/dist/knowledge/skills/human-decision-notices/references/framework-decision-card-wording-api.md +9 -0
- package/dist/knowledge/skills/human-decision-notices/references/framework-decision-notice-handler-api.md +7 -0
- package/dist/knowledge/skills/inbound-channels/references/framework-inbound-handler-api.md +2 -1
- package/dist/knowledge/skills/inbound-channels/references/receiving-email.md +33 -2
- package/dist/knowledge/skills/infra-environment-config/SKILL.md +31 -9
- package/dist/knowledge/skills/infra-environment-config/references/framework-environment-deployment-api.md +27 -4
- package/dist/knowledge/skills/local-environment-bootstrap/references/wildo-cli-bootstrap-commands.md +26 -0
- package/dist/knowledge/skills/module-registration/references/framework-domain-modules-api.md +15 -0
- package/dist/knowledge/skills/module-relationships/SKILL.md +27 -1
- package/dist/knowledge/skills/provider-backend-package/SKILL.md +32 -4
- package/dist/knowledge/skills/provider-frontend-file-picker/references/framework-frontend-provider-consent-api.md +2 -0
- package/dist/knowledge/skills/provider-frontend-module/SKILL.md +3 -0
- package/dist/knowledge/skills/resource-add-module/SKILL.md +8 -2
- package/dist/knowledge/skills/resource-add-module/references/module-scaffold-layout.md +17 -0
- package/dist/knowledge/skills/resource-chat-commands/SKILL.md +1 -1
- package/dist/knowledge/skills/resource-external-data/references/framework-http-api-binding-api.md +51 -0
- package/dist/knowledge/skills/resource-external-data/references/incremental-extraction.md +14 -5
- package/dist/knowledge/skills/resource-external-data/references/read-through-writes.md +30 -0
- package/dist/knowledge/skills/resource-mcp-tool-exposure/references/mcp-client-registration-postures.md +5 -0
- package/dist/knowledge/skills/resource-rag-source-fields/references/framework-rag-retrieval-api.md +4 -2
- package/dist/knowledge/skills/settings-placement-authoring/references/framework-settings-destinations-catalog.md +21 -0
- package/dist/knowledge/skills/views-composite-authoring/SKILL.md +5 -0
- package/dist/knowledge/skills/views-composite-authoring/references/framework-composite-view-contracts-api.md +19 -0
- package/dist/knowledge/topic-index.json +295 -114
- package/dist/tsconfig.build.tsbuildinfo +1 -1
- package/package.json +4 -4
|
@@ -20,7 +20,7 @@ export declare const playbookDefinition: {
|
|
|
20
20
|
readonly ref: "bottom_up.assemble-verify";
|
|
21
21
|
readonly version: "0.4.3";
|
|
22
22
|
readonly phase: "bottom_up";
|
|
23
|
-
readonly intent: "Bottom-up assemble & verify — the FINAL bottom-up step and the capstone of the build: the pivot from having BUILT the application (the decompose / dispatch / scale loop authored its modules, resources, config and integrations) to answering ONE mechanical question — does the built application ASSEMBLE? It runs the deterministic verification set over EVERY workspace package the application has (specifications, shared-lib, backend-api, frontend, and the website, technical documentation site, workers and minions it composed), derived from those packages rather than listed, OUTSIDE any coding agent, and reports a per-check outcome. It fixes NOTHING: a failure is surfaced for a refinement re-dispatch, which is a different playbook's job, and it authors no schemas and writes no code. Deliberately DISTINCT from the refinement phase's coverage audit, which also binds topic 7 but asks a SEMANTIC question (does the built app match the intent — specs diffed against introspected reality). This playbook never diffs intent against reality; if you are judging coverage you are in the refinement lane. Scope honesty: the check set is the whole-application TYPECHECK across every package — the question 'does it compile as one program', which no per-task check can answer because the dispatch lane typechecks only the package a task mutated — PLUS the schema-plan drift gate (`check:schema-plan-in-sync`), which asks whether the modelled resources have migrations behind them. The second is not a variant of the first: on a PostgreSQL-backed application a table exists only because a migration built it, so a resource whose migration was never generated compiles green in every package and then refuses to boot on `postgresql_table_schema_mismatch` — invisible to a typecheck, because no type in the program knows whether a table exists. It is safe on MongoDB applications and on unbuilt trees because it resolves three outcomes (not adopted / could-not-ask / decided) rather than reading an exit code. Since #2228 it also asks the two questions a typecheck cannot: does each optional site BUILD (the website's `astro build`, the documentation portal's `docusaurus build`; an absent package answers 'nothing to build'), and does the configuration pass `wildo config validate` (errors fail, warnings do not, a missing CLI is 'we could not ask'); and it asks the RUNNING backend's readiness and renders the frontend in a browser, each reported unrun rather than passed when the stack is not up. Since #2404 it also builds the resources registry offline, as the backend's startup does (`check:resources-registry-init`), so a resource configuration the engine refuses at start is named before the running backend is asked. Since #2784 it also holds the website's drawn demos to the application (`check:website-demo-facts`), because a later resource change can make a landed drawing untrue. Since #3211 it also evaluates the specifications package as the companion does (`check:specification-exports`), so a specification its factory refuses — valid TypeScript, dropped from what the companion serves — is named. The whole test suite and OpenAPI/docs regeneration are NOT in this set.";
|
|
23
|
+
readonly intent: "Bottom-up assemble & verify — the FINAL bottom-up step and the capstone of the build: the pivot from having BUILT the application (the decompose / dispatch / scale loop authored its modules, resources, config and integrations) to answering ONE mechanical question — does the built application ASSEMBLE? It runs the deterministic verification set over EVERY workspace package the application has (specifications, shared-lib, backend-api, frontend, and the website, technical documentation site, workers and minions it composed), derived from those packages rather than listed, OUTSIDE any coding agent, and reports a per-check outcome. It fixes NOTHING: a failure is surfaced for a refinement re-dispatch, which is a different playbook's job, and it authors no schemas and writes no code. Deliberately DISTINCT from the refinement phase's coverage audit, which also binds topic 7 but asks a SEMANTIC question (does the built app match the intent — specs diffed against introspected reality). This playbook never diffs intent against reality; if you are judging coverage you are in the refinement lane. Scope honesty: the check set is the whole-application TYPECHECK across every package — the question 'does it compile as one program', which no per-task check can answer because the dispatch lane typechecks only the package a task mutated — PLUS the schema-plan drift gate (`check:schema-plan-in-sync`), which asks whether the modelled resources have migrations behind them. The second is not a variant of the first: on a PostgreSQL-backed application a table exists only because a migration built it, so a resource whose migration was never generated compiles green in every package and then refuses to boot on `postgresql_table_schema_mismatch` — invisible to a typecheck, because no type in the program knows whether a table exists. It is safe on MongoDB applications and on unbuilt trees because it resolves three outcomes (not adopted / could-not-ask / decided) rather than reading an exit code. Since #2228 it also asks the two questions a typecheck cannot: does each optional site BUILD (the website's `astro build`, the documentation portal's `docusaurus build`; an absent package answers 'nothing to build'), and does the configuration pass `wildo config validate` (errors fail, warnings do not, a missing CLI is 'we could not ask'); and it asks the RUNNING backend's readiness and renders the frontend in a browser, each reported unrun rather than passed when the stack is not up. Since #2404 it also builds the resources registry offline, as the backend's startup does (`check:resources-registry-init`), so a resource configuration the engine refuses at start is named before the running backend is asked. Since #2784 it also holds the website's drawn demos to the application (`check:website-demo-facts`), because a later resource change can make a landed drawing untrue. Since #3211 it also evaluates the specifications package as the companion does (`check:specification-exports`), so a specification its factory refuses — valid TypeScript, dropped from what the companion serves — is named. Since #3904 it also holds every module's conventional files to the folders the framework reads them from (`check:module-layout`), so a misplacement a task's own check carried is asked once more. The whole test suite and OpenAPI/docs regeneration are NOT in this set.";
|
|
24
24
|
readonly preconditions: readonly [{
|
|
25
25
|
readonly kind: "artifact_exists";
|
|
26
26
|
readonly selector: {
|
|
@@ -20,7 +20,7 @@ export const playbookDefinition = {
|
|
|
20
20
|
"ref": "bottom_up.assemble-verify",
|
|
21
21
|
"version": "0.4.3",
|
|
22
22
|
"phase": "bottom_up",
|
|
23
|
-
"intent": "Bottom-up assemble & verify — the FINAL bottom-up step and the capstone of the build: the pivot from having BUILT the application (the decompose / dispatch / scale loop authored its modules, resources, config and integrations) to answering ONE mechanical question — does the built application ASSEMBLE? It runs the deterministic verification set over EVERY workspace package the application has (specifications, shared-lib, backend-api, frontend, and the website, technical documentation site, workers and minions it composed), derived from those packages rather than listed, OUTSIDE any coding agent, and reports a per-check outcome. It fixes NOTHING: a failure is surfaced for a refinement re-dispatch, which is a different playbook's job, and it authors no schemas and writes no code. Deliberately DISTINCT from the refinement phase's coverage audit, which also binds topic 7 but asks a SEMANTIC question (does the built app match the intent — specs diffed against introspected reality). This playbook never diffs intent against reality; if you are judging coverage you are in the refinement lane. Scope honesty: the check set is the whole-application TYPECHECK across every package — the question 'does it compile as one program', which no per-task check can answer because the dispatch lane typechecks only the package a task mutated — PLUS the schema-plan drift gate (`check:schema-plan-in-sync`), which asks whether the modelled resources have migrations behind them. The second is not a variant of the first: on a PostgreSQL-backed application a table exists only because a migration built it, so a resource whose migration was never generated compiles green in every package and then refuses to boot on `postgresql_table_schema_mismatch` — invisible to a typecheck, because no type in the program knows whether a table exists. It is safe on MongoDB applications and on unbuilt trees because it resolves three outcomes (not adopted / could-not-ask / decided) rather than reading an exit code. Since #2228 it also asks the two questions a typecheck cannot: does each optional site BUILD (the website's `astro build`, the documentation portal's `docusaurus build`; an absent package answers 'nothing to build'), and does the configuration pass `wildo config validate` (errors fail, warnings do not, a missing CLI is 'we could not ask'); and it asks the RUNNING backend's readiness and renders the frontend in a browser, each reported unrun rather than passed when the stack is not up. Since #2404 it also builds the resources registry offline, as the backend's startup does (`check:resources-registry-init`), so a resource configuration the engine refuses at start is named before the running backend is asked. Since #2784 it also holds the website's drawn demos to the application (`check:website-demo-facts`), because a later resource change can make a landed drawing untrue. Since #3211 it also evaluates the specifications package as the companion does (`check:specification-exports`), so a specification its factory refuses — valid TypeScript, dropped from what the companion serves — is named. The whole test suite and OpenAPI/docs regeneration are NOT in this set.",
|
|
23
|
+
"intent": "Bottom-up assemble & verify — the FINAL bottom-up step and the capstone of the build: the pivot from having BUILT the application (the decompose / dispatch / scale loop authored its modules, resources, config and integrations) to answering ONE mechanical question — does the built application ASSEMBLE? It runs the deterministic verification set over EVERY workspace package the application has (specifications, shared-lib, backend-api, frontend, and the website, technical documentation site, workers and minions it composed), derived from those packages rather than listed, OUTSIDE any coding agent, and reports a per-check outcome. It fixes NOTHING: a failure is surfaced for a refinement re-dispatch, which is a different playbook's job, and it authors no schemas and writes no code. Deliberately DISTINCT from the refinement phase's coverage audit, which also binds topic 7 but asks a SEMANTIC question (does the built app match the intent — specs diffed against introspected reality). This playbook never diffs intent against reality; if you are judging coverage you are in the refinement lane. Scope honesty: the check set is the whole-application TYPECHECK across every package — the question 'does it compile as one program', which no per-task check can answer because the dispatch lane typechecks only the package a task mutated — PLUS the schema-plan drift gate (`check:schema-plan-in-sync`), which asks whether the modelled resources have migrations behind them. The second is not a variant of the first: on a PostgreSQL-backed application a table exists only because a migration built it, so a resource whose migration was never generated compiles green in every package and then refuses to boot on `postgresql_table_schema_mismatch` — invisible to a typecheck, because no type in the program knows whether a table exists. It is safe on MongoDB applications and on unbuilt trees because it resolves three outcomes (not adopted / could-not-ask / decided) rather than reading an exit code. Since #2228 it also asks the two questions a typecheck cannot: does each optional site BUILD (the website's `astro build`, the documentation portal's `docusaurus build`; an absent package answers 'nothing to build'), and does the configuration pass `wildo config validate` (errors fail, warnings do not, a missing CLI is 'we could not ask'); and it asks the RUNNING backend's readiness and renders the frontend in a browser, each reported unrun rather than passed when the stack is not up. Since #2404 it also builds the resources registry offline, as the backend's startup does (`check:resources-registry-init`), so a resource configuration the engine refuses at start is named before the running backend is asked. Since #2784 it also holds the website's drawn demos to the application (`check:website-demo-facts`), because a later resource change can make a landed drawing untrue. Since #3211 it also evaluates the specifications package as the companion does (`check:specification-exports`), so a specification its factory refuses — valid TypeScript, dropped from what the companion serves — is named. Since #3904 it also holds every module's conventional files to the folders the framework reads them from (`check:module-layout`), so a misplacement a task's own check carried is asked once more. The whole test suite and OpenAPI/docs regeneration are NOT in this set.",
|
|
24
24
|
"preconditions": [
|
|
25
25
|
{ "kind": "artifact_exists", "selector": { "family": "build-plan" } }
|
|
26
26
|
],
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"playbook.definition.js","sourceRoot":"","sources":["../../../../src/playbooks/bottom_up.assemble-verify/playbook.definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAC/B;IACE,KAAK,EAAE,2BAA2B;IAClC,SAAS,EAAE,OAAO;IAClB,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,
|
|
1
|
+
{"version":3,"file":"playbook.definition.js","sourceRoot":"","sources":["../../../../src/playbooks/bottom_up.assemble-verify/playbook.definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAC/B;IACE,KAAK,EAAE,2BAA2B;IAClC,SAAS,EAAE,OAAO;IAClB,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,8yGAA8yG;IACxzG,eAAe,EAAE;QACf,EAAE,MAAM,EAAE,iBAAiB,EAAE,UAAU,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,EAAE;KACtE;IACD,QAAQ,EAAE;QACR,EAAE,QAAQ,EAAE,YAAY,EAAE;KAC3B;IACD,SAAS,EAAE,EAAE;IACb,QAAQ,EAAE;QACR,WAAW,EAAE;YACX,iCAAiC;SAClC;KACF;IACD,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE,gBAAgB;IAC5B,uGAAuG;IACvG,QAAQ,EAAE;QACR,SAAS,EAAE,EAAE;KACd;IACD,WAAW,EAAE,eAAe;CACpB,CAAC","sourcesContent":["/**\n * Canonical native declaration for topic 7 — the app-wide assemble/verify step.\n *\n * REBUILT rather than restored (issue #147). A playbook of this ref existed from\n * 2026-07-10 and was deleted on 2026-08-25 with the app-creation digest\n * demolition; the question it asked went with it, even though answering \"does\n * the built application assemble?\" needs no digests. Restoring it verbatim was\n * rejected: it declared the retired `COMPOSITE` executor, depended on two\n * families the demolition removed (`foundation-manifest`, `build-verification`),\n * and its method was explicit that NONE of its checks were actually run by the\n * runner — `// TODO CLI COMMAND:` placeholders and \"companion affordances that\n * do not exist yet\".\n *\n * What is different now is that the checks RUN. `DETERMINISTIC_CLI` is honoured\n * by the runtime as of #147, and the check refs below resolve through the same\n * closed `APPLICATION_CODING_TASK_VERIFICATION_CATALOG` a coding task uses, so\n * an unknown ref is refused rather than silently skipped.\n */\nexport const playbookDefinition =\n{\n \"ref\": \"bottom_up.assemble-verify\",\n \"version\": \"0.4.3\",\n \"phase\": \"bottom_up\",\n \"intent\": \"Bottom-up assemble & verify — the FINAL bottom-up step and the capstone of the build: the pivot from having BUILT the application (the decompose / dispatch / scale loop authored its modules, resources, config and integrations) to answering ONE mechanical question — does the built application ASSEMBLE? It runs the deterministic verification set over EVERY workspace package the application has (specifications, shared-lib, backend-api, frontend, and the website, technical documentation site, workers and minions it composed), derived from those packages rather than listed, OUTSIDE any coding agent, and reports a per-check outcome. It fixes NOTHING: a failure is surfaced for a refinement re-dispatch, which is a different playbook's job, and it authors no schemas and writes no code. Deliberately DISTINCT from the refinement phase's coverage audit, which also binds topic 7 but asks a SEMANTIC question (does the built app match the intent — specs diffed against introspected reality). This playbook never diffs intent against reality; if you are judging coverage you are in the refinement lane. Scope honesty: the check set is the whole-application TYPECHECK across every package — the question 'does it compile as one program', which no per-task check can answer because the dispatch lane typechecks only the package a task mutated — PLUS the schema-plan drift gate (`check:schema-plan-in-sync`), which asks whether the modelled resources have migrations behind them. The second is not a variant of the first: on a PostgreSQL-backed application a table exists only because a migration built it, so a resource whose migration was never generated compiles green in every package and then refuses to boot on `postgresql_table_schema_mismatch` — invisible to a typecheck, because no type in the program knows whether a table exists. It is safe on MongoDB applications and on unbuilt trees because it resolves three outcomes (not adopted / could-not-ask / decided) rather than reading an exit code. Since #2228 it also asks the two questions a typecheck cannot: does each optional site BUILD (the website's `astro build`, the documentation portal's `docusaurus build`; an absent package answers 'nothing to build'), and does the configuration pass `wildo config validate` (errors fail, warnings do not, a missing CLI is 'we could not ask'); and it asks the RUNNING backend's readiness and renders the frontend in a browser, each reported unrun rather than passed when the stack is not up. Since #2404 it also builds the resources registry offline, as the backend's startup does (`check:resources-registry-init`), so a resource configuration the engine refuses at start is named before the running backend is asked. Since #2784 it also holds the website's drawn demos to the application (`check:website-demo-facts`), because a later resource change can make a landed drawing untrue. Since #3211 it also evaluates the specifications package as the companion does (`check:specification-exports`), so a specification its factory refuses — valid TypeScript, dropped from what the companion serves — is named. Since #3904 it also holds every module's conventional files to the folders the framework reads them from (`check:module-layout`), so a misplacement a task's own check carried is asked once more. The whole test suite and OpenAPI/docs regeneration are NOT in this set.\",\n \"preconditions\": [\n { \"kind\": \"artifact_exists\", \"selector\": { \"family\": \"build-plan\" } }\n ],\n \"inputs\": [\n { \"family\": \"build-plan\" }\n ],\n \"outputs\": [],\n \"method\": {\n \"skillRefs\": [\n \"application-database-migrations\"\n ]\n },\n \"executor\": \"deterministic_cli\",\n \"approval\": \"approve_result\",\n // How many times the step may run (#1344). It makes no model call: it runs typechecks in a subprocess.\n \"budget\": {\n \"maxRuns\": 40\n },\n \"onFailure\": \"keep_and_flag\",\n} as const;\n"]}
|
|
@@ -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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
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:
|
|
155
|
-
*
|
|
156
|
-
*
|
|
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
|
|
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"]}
|
|
@@ -51,7 +51,7 @@ export declare const playbookDefinition: {
|
|
|
51
51
|
readonly outputs: readonly [{
|
|
52
52
|
readonly family: "integration-plan";
|
|
53
53
|
readonly schemaRef: "saas-specifications:IntegrationPlan";
|
|
54
|
-
readonly description: "What this application runs beside its backend and what it reaches out to: its workers (each with its runtime, what the backend delegates to it, the routes it registers and what it is accountable to), its cron minions (each with what happens because time passed, its named behaviours, and exactly which resources its tick reads and writes),
|
|
54
|
+
readonly description: "What this application runs beside its backend and what it reaches out to: its workers (each with its runtime, what the backend delegates to it, the routes it registers and what it is accountable to), its cron minions (each with what happens because time passed, its named behaviours, and exactly which resources its tick reads and writes), the providers it binds into each runtime owner's scope, and any need no engine provider or registry module fills, with why (the only door to authoring a new provider). Every collection may be empty, and saying so is an answer.";
|
|
55
55
|
}];
|
|
56
56
|
readonly method: {
|
|
57
57
|
readonly contextSources: readonly ["workspace_truth", "provider_registry"];
|
|
@@ -44,7 +44,7 @@ export const playbookDefinition = {
|
|
|
44
44
|
{
|
|
45
45
|
"family": "integration-plan",
|
|
46
46
|
"schemaRef": "saas-specifications:IntegrationPlan",
|
|
47
|
-
"description": "What this application runs beside its backend and what it reaches out to: its workers (each with its runtime, what the backend delegates to it, the routes it registers and what it is accountable to), its cron minions (each with what happens because time passed, its named behaviours, and exactly which resources its tick reads and writes),
|
|
47
|
+
"description": "What this application runs beside its backend and what it reaches out to: its workers (each with its runtime, what the backend delegates to it, the routes it registers and what it is accountable to), its cron minions (each with what happens because time passed, its named behaviours, and exactly which resources its tick reads and writes), the providers it binds into each runtime owner's scope, and any need no engine provider or registry module fills, with why (the only door to authoring a new provider). Every collection may be empty, and saying so is an answer."
|
|
48
48
|
}
|
|
49
49
|
],
|
|
50
50
|
"method": {
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"playbook.definition.js","sourceRoot":"","sources":["../../../../src/playbooks/bottom_up.integration-plan/playbook.definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,KAAK,EAAE,4BAA4B;IACnC,SAAS,EAAE,OAAO;IAClB,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,+yBAA+yB;IACzzB,eAAe,EAAE;QACf;;;;WAIG;QACH,EAAE,MAAM,EAAE,iBAAiB,EAAE,UAAU,EAAE,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE;KACvE;IACD,QAAQ,EAAE;QACR,EAAE,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,sJAAsJ,EAAE;QAC1L,EAAE,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,+DAA+D,EAAE;QACrG,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,wFAAwF,EAAE;QAC3H,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,wJAAwJ,EAAE;QACxM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,IAAI,EAAE,oLAAoL,EAAE;KAC7N;IACD,SAAS,EAAE;QACT;YACE,QAAQ,EAAE,kBAAkB;YAC5B,WAAW,EAAE,qCAAqC;YAClD,aAAa,EAAE,
|
|
1
|
+
{"version":3,"file":"playbook.definition.js","sourceRoot":"","sources":["../../../../src/playbooks/bottom_up.integration-plan/playbook.definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,KAAK,EAAE,4BAA4B;IACnC,SAAS,EAAE,OAAO;IAClB,OAAO,EAAE,WAAW;IACpB,QAAQ,EAAE,+yBAA+yB;IACzzB,eAAe,EAAE;QACf;;;;WAIG;QACH,EAAE,MAAM,EAAE,iBAAiB,EAAE,UAAU,EAAE,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE;KACvE;IACD,QAAQ,EAAE;QACR,EAAE,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,sJAAsJ,EAAE;QAC1L,EAAE,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,+DAA+D,EAAE;QACrG,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,wFAAwF,EAAE;QAC3H,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,wJAAwJ,EAAE;QACxM,EAAE,QAAQ,EAAE,kBAAkB,EAAE,IAAI,EAAE,oLAAoL,EAAE;KAC7N;IACD,SAAS,EAAE;QACT;YACE,QAAQ,EAAE,kBAAkB;YAC5B,WAAW,EAAE,qCAAqC;YAClD,aAAa,EAAE,wjBAAwjB;SACxkB;KACF;IACD,QAAQ,EAAE;QACR;;;;;;;;;;WAUG;QACH,gBAAgB,EAAE,CAAC,iBAAiB,EAAE,mBAAmB,CAAC;QAC1D;;;;;;WAMG;QACH,eAAe,EAAE,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;QACzD,WAAW,EAAE;YACX,kBAAkB;YAClB,kBAAkB;YAClB,0BAA0B;YAC1B,+BAA+B;YAC/B,0BAA0B;YAC1B,wBAAwB;YACxB,mBAAmB;YACnB,kBAAkB;SACnB;KACF;IACD,UAAU,EAAE,iBAAiB;IAC7B,UAAU,EAAE,gBAAgB;IAC5B,QAAQ,EAAE;QACR,SAAS,EAAE,CAAC;KACb;IACD,WAAW,EAAE,eAAe;CACpB,CAAC","sourcesContent":["/**\n * Canonical native declaration for this reusable application-creation method.\n *\n * The background-execution and external-reach leaf (#1495). `add-minion`, `add-worker-node`,\n * `add-worker-rust`, `add-provider` and `add-file-picker-provider` all shipped as scenarios, and\n * the decomposer was told to plan \"workers / minions and other auxiliary execution surfaces\" and\n * \"providers, external connectors, billing wiring\" — with no product kind for any of them and,\n * measured 2026-09-22, ZERO worker and minion skills in the catalog. Nothing in the journey could\n * give an application a background worker, a cron minion or a provider binding.\n *\n * It produces the integration plan. Two consumers read it, and the split is the point:\n *\n * - `bottom_up.foundation` composes the PACKAGE — one `add-worker-node`, `add-worker-rust` or\n * `add-minion` per surface, fanned out exactly as modules and resources are fanned out of the\n * domain plan. That is why the capability composition reports those three scenarios as owned by\n * the foundation rather than as undecidable, which is what they read until this family existed.\n * - `bottom_up.build-decompose` emits the WORK — one task per worker, minion and provider binding,\n * each bound to its skill through the three total maps in `_core`, and one per inbound channel\n * producing its handler, which the dispatch routes to `inbound-channels` from the product (#1832).\n *\n * The build plan keeps ONE producer, which is what makes landing decidable (#895).\n */\nexport const playbookDefinition = {\n \"ref\": \"bottom_up.integration-plan\",\n \"version\": \"0.2.0\",\n \"phase\": \"bottom_up\",\n \"intent\": \"Background execution and external reach — decide WHAT RUNS BESIDE THE BACKEND and WHAT THIS APPLICATION REACHES OUT TO: which workers exist and on which runtime, which cron minions wake on their own and exactly which resources each one may read and write, and which providers are bound into which runtime owner's scope. Reads the requirements and feature drafts (what somebody asked for, including the work that cannot happen inside a request), the domain plan (the resources a minion's containment whitelist names) and the roadmap (what is owed when). Every surface names what it is accountable to, because a process nobody asked for is a process nobody maintains. Produces the plan; the foundation composes each package and the decomposer emits the work, each task bound to the skill its runtime or scope names.\",\n \"preconditions\": [\n /*\n * The DOMAIN PLAN is what a minion's containment is OVER: `readsResourceRefs` and\n * `writesResourceRefs` name decided resources, and a whitelist naming resources nobody decided\n * contains nothing. Its CONTENT is read, so `artifact_exists` is the honest strength (#1434).\n */\n { \"kind\": \"artifact_exists\", \"selector\": { \"family\": \"domain-plan\" } }\n ],\n \"inputs\": [\n { \"family\": \"requirements\", \"//\": \"What somebody asked the application to do — including the work that cannot happen inside a request, which is the only honest reason a worker exists.\" },\n { \"family\": \"feature-drafts\", \"//\": \"The drafted features whose work a background surface carries.\" },\n { \"family\": \"domain-plan\", \"//\": \"The resources a minion's containment whitelist names, and the modules a worker serves.\" },\n { \"family\": \"roadmap\", \"render\": \"map\", \"//\": \"When each phase is owed, so a surface is planned against the phase that needs it. A MAP: the phases' own rationale is not this method's input (#1424).\" },\n { \"family\": \"integration-plan\", \"//\": \"Its own family: its method refines its own prior output and keeps its worker and minion refs, which build tasks name (#1430). Input, not precondition: a first run stays eligible.\" }\n ],\n \"outputs\": [\n {\n \"family\": \"integration-plan\",\n \"schemaRef\": \"saas-specifications:IntegrationPlan\",\n \"description\": \"What this application runs beside its backend and what it reaches out to: its workers (each with its runtime, what the backend delegates to it, the routes it registers and what it is accountable to), its cron minions (each with what happens because time passed, its named behaviours, and exactly which resources its tick reads and writes), the providers it binds into each runtime owner's scope, and any need no engine provider or registry module fills, with why (the only door to authoring a new provider). Every collection may be empty, and saying so is an answer.\"\n }\n ],\n \"method\": {\n /*\n * WORKSPACE_TRUTH — this method plans against CODE as well as against decisions: which workers\n * and minions the application ALREADY carries (its `applicationWorkers` / `applicationMinions`\n * buckets), and which providers its scopes already name. A plan proposing a worker the tree\n * already has emits a task that composes a package twice.\n *\n * PROVIDER_REGISTRY (#2025) — the provider modules the registry OFFERS. Since the catalogue was\n * archived (#2019) a vendor reaches an application only by being installed from the registry, so\n * the workspace alone shows what is installed and nothing that could be added: an OCR or Teams need\n * was planned against nothing, or against a vendor recalled from training that no module provides.\n */\n \"contextSources\": [\"workspace_truth\", \"provider_registry\"],\n /*\n * TWO bodies reach this step (#1435), and they are the two the plan's central decisions depend\n * on: whether a surface is a worker or a minion, and what a minion's containment must name.\n * Both are impossible to decide from recollection — the difference is a runtime contract, and\n * the containment chain has three parts of which two are outside the minion's own package.\n * Every other skill is a contract the CODING AGENT opens when it builds the task.\n */\n \"skillBodyRefs\": [\"worker-authoring\", \"minion-authoring\"],\n \"skillRefs\": [\n \"worker-authoring\",\n \"minion-authoring\",\n \"provider-backend-package\",\n \"provider-frontend-file-picker\",\n \"provider-operation-calls\",\n \"resource-external-data\",\n \"configure-billing\",\n \"inbound-channels\"\n ]\n },\n \"executor\": \"companion_agent\",\n \"approval\": \"approve_result\",\n \"budget\": {\n \"maxRuns\": 3\n },\n \"onFailure\": \"keep_and_flag\"\n} as const;\n"]}
|