gennady 0.6.0 → 0.7.0

package/dist/ai/directives/sdd/scaffold.directive.xml

@@ -0,0 +1,717 @@
+<SddTaskScaffolding keywords="task-scaffolding, dependency-graph, bdd, execution-planning, mandatory-rules-linkage, rules-cascade, rule-activation, hierarchical-tasks, modes, extend-dag, scope-graph, sdd-phase-3" type="directive" ver="3.0">
+  <Directive_Context>
+    <Mission>
+      Decompose the spec tree into a DAG of compact task tickets ready for autonomous execution by `sdd-execute` orchestrator (which dispatches phase-subagents under `phase-execution-protocol`).
+
+      Convergence point. Entry point: `specs/README.md` Scope Graph — canonical map of all scopes and their dependencies. From Portal extract:
+      - All scopes with their scope-type and `depends-on` edges (Mermaid graph + Scopes table).
+      - Per scope: read `specs/<scope>/<scope>.spec.md` for rules, requirements, architecture.
+      - Per product/library scope: read `specs/<scope>/<module>/<module>.spec.md` if 8 Module Map exists.
+
+      Outputs:
+      - `tasks/README.md` — project-level tracker (Entry Points, Tracker Index, High-Level cross-scope DAG, Decision Log). No global Cascade Table here — each scope has its own.
+      - `tasks/<scope>/README.md` — per-scope tracker: Cascade Table (derived from scope graph), intra-scope DAG, Tracker.
+      - `tasks/<scope>/<scope>.task-NN.md` — compact tickets for scope-level tasks.
+      - `tasks/<scope>/<module>/<module>.task-NN.md` — module-level tickets (when modules exist in scope).
+      - `tasks/integration/` — cross-scope integration tickets (optional; only when a dedicated `integration` scope is registered in Scope Graph).
+
+      Next phase: `sdd-execute` consumes one ticket at a time, dispatches phase-subagents per ticket's Phases Overview, then `audit`.
+
+      **Glossary.** Orchestrator = agent under `sdd-execute` SKILL. Phase agent = subagent under `phase-execution-protocol`. Auditor = agent under `audit`. Scope = architecturally cohesive unit from scope graph. scope-type ∈ {infrastructure, contracts, library, product}.
+    </Mission>
+  </Directive_Context>
+
+  <Belief_State>
+    <Axiom id="AX_DIRECTIVE_MODE">
+      **Two modes, auto-detected from intake:**
+      - `initial` — first run, `tasks/` absent or empty.
+      - `extend-dag` — add tickets for new/refined scope or module or pivot list, without regenerating existing.
+    </Axiom>
+
+    <Axiom id="AX_MODE_AUTO_DETECT_OR_HALT">
+      | Condition | Mode |
+      |---|---|
+      | No `tasks/` OR empty | `initial` |
+      | `tasks/` present + intake names new/refined scope or module OR Pivot Invalidation List | `extend-dag` |
+      | `tasks/` present + intake unclear | HALT, ask operator |
+    </Axiom>
+
+    <Axiom id="AX_SPEC_IS_SOLE_SOURCE">
+      **Phase reads specs only, never code.** Allowed inputs: operator intake; `specs/README.md`; per-scope spec files; per-module spec files; in `extend-dag` — existing `tasks/` artifacts (for max Task-ID + current DAG); rule files at `ai/directives/<category>/<rule>.xml`. No project-wide search (grep / find / ripgrep) outside the listed reads. Spec/code mismatch is resolved by `audit`.
+    </Axiom>
+
+    <Axiom id="AX_SCOPE_GRAPH_DETECTION">
+      Detection is driven by `specs/README.md` Scope Graph (Mermaid `graph TD`) and Scopes table. Portal absent → no specs → HALT.
+
+      From Portal extract:
+      - All scope names and their scope-types (from Scopes table).
+      - Dependency edges A→B (from Mermaid graph or Scopes table `depends-on`).
+      - For each scope with ✅ status, read its spec file at `specs/<scope>/<scope>.spec.md`.
+
+      Cascade computation requires full scope graph traversal:
+      - **Traversed-scopes** for a target scope = all scopes reachable via `depends-on` edges (transitive closure).
+      - **Cascade** = union of Effective Rules from traversed-scopes + target-scope rules + (module rules if product/library) + task additions.
+
+      | Scopes present | Result |
+      |---|---|
+      | Only infrastructure scopes | scaffold infra tasks only; no module trackers |
+      | Mix of product/library + infra/contracts | full project; infra tasks = DAG roots |
+      | No scopes at all | HALT: no spec input |
+    </Axiom>
+
+    <Axiom id="AX_EXTEND_DAG_PRESERVES_EXISTING_IDS">
+      **In `extend-dag`, existing Task-IDs and ticket files are immutable.**
+
+      - New tasks get next sequential `TSK-NN` after max existing.
+      - Existing tickets are NOT regenerated even if upstream specs changed — that is the orchestrator's reopen scenario via `sdd-execute`, not regeneration.
+      - `add-scope` upstream → scaffold only for the new scope.
+      - `add-module` or `refine-module` upstream → scaffold only for the new/changed surface; unchanged-surface tickets untouched.
+      - Per-scope Cascade Table may update; existing tickets keep their old per-phase `Rules:` lists — orchestrator re-derives on reopen if the operator opts in.
+      - DAG edges/IDs preserved; new tasks appended.
+    </Axiom>
+
+    <Axiom id="AX_RULES_RESOLUTION_HARD_FAIL">
+      **All rule references must resolve; missing rule = abort.** Sources: scope spec (5 Effective Rules for infra; 4.5 Rules for product/library), module spec (9 Handoff Module Rules Additions), task (operator-supplied at STEP_4). Each ref must exist as `ai/directives/<category>/<rule>.xml`. On miss: abort with explicit list. A placeholder rule reference (TBD, `<rule>`, "to be authored", any unresolved name) = abort, never write a ticket against it.
+    </Axiom>
+
+    <Axiom id="AX_RULES_CASCADE_RESOLUTION">
+      **Effective rule-set per task = union of 5 tiers; later tier overrides earlier on collision.**
+
+      Tier order (low → high):
+      1. **traversed-scopes** — union of Effective Rules from all scopes reachable via `depends-on` from target scope (transitive closure).
+      2. **target-scope** — scope spec 5 Effective Rules (infra) or 4.5 Rules (product/library).
+      3. **module:<name>** — module spec 9 Handoff Module Rules Additions (when modules exist).
+      4. **task** — operator-supplied during ticket generation.
+
+      Materialization:
+      - **Cascade Table** (Scope × Categories) lives in `tasks/<scope>/README.md` per scope, NOT in `tasks/README.md`. Generated from scope graph automatically.
+      - **Per-phase `Rules:` bullet list** inside each ticket's section 3 Phases block: derived by scaffolder per `AX_RULE_ACTIVATION_PLAN` from cascade × THAT PHASE's Target Files + kind. Rules are NOT declared at ticket level — only per phase.
+      - Auditor recomputes effective set per-phase from sources and compares with each phase block.
+    </Axiom>
+
+    <Axiom id="AX_RULE_ACTIVATION_PLAN">
+      Rules are resolved per phase, not per ticket. For each phase declared in the ticket's section 2 Phases Overview:
+
+      1. Read `ai/directives/knowledge.xml` — the canonical rule registry (`<Rules>` section).
+      2. From the scope's Project-Wide Rules, extract the candidate rule set for this scope.
+      3. For each candidate rule: evaluate its `<Triggers>` and `<SkipWhen>` against THIS PHASE's `Target Files` and phase `kind`. Include the rule only when `<Triggers>` match AND `<SkipWhen>` does not apply. Signal-based only — no hardcoded language/tool knowledge in this directive.
+      4. **Transitive closure via `<Depends_On>`.** For each included rule, open its file and read its `<Depends_On>` section (optional; lists rule-file paths this rule architecturally extends). Add every dependency to the phase's Rules set. Recurse until the set stops growing. Cycles → halt `H_RULES_CYCLE`. Missing dependency file → halt `H_MISSING_RULES`. This produces the explicit, fully-resolved set; phase-subagent does NOT walk `<Depends_On>` at runtime.
+      5. For each rule in the resolved set:
+         - `<File>` → full path to rule file (`ai/directives/<category>/<rule>.xml`); render as Markdown link in the phase's `Rules:` bullet list.
+         - `<RequiresVerification>` → collect aliases for ticket-level Verification table (step 7).
+      6. Write the phase's `Rules:` bullet list with one `[<rule-id>](<rule-file-path>)` per included rule (direct + transitive, all explicit).
+      7. After all phases are processed, collect the union of all `<RequiresVerification>` aliases across all phases of this ticket. Group rules by alias (multiple rules may share `check-command`). Resolve each unique alias from infra-spec Verification Commands.
+         - Alias present in spec → use its invocation.
+         - Alias absent → halt: H_VERIFICATION_COMMAND_MISSING (alias, ticket ID).
+      8. Write ticket section 5 Verification table (ticket-level, single table):
+         | Command | Required by |
+         One row per unique alias. "Required by" = comma-separated rule IDs that declared it. Phase-subagent runs only the rows whose Required-by intersects with its phase's `Rules`.
+    </Axiom>
+
+    <Axiom id="AX_DAG_AND_TICKET_BOUNDARIES">
+      **Topological order, no cycles. Default: minimum tickets — one per coherent spec unit.** Product / library scope → one ticket per module-spec. Infrastructure / contracts scope → one ticket per discrete capability.
+
+      DAG edges derive from real file-level dependencies, Bootstrap → consumers, and cross-scope `depends-on`. No «logical layer» phases — Ports → Adapters → Integrations is an analysis aid in discovery, NOT a ticket-multiplication rule. A Port and its single confirmed-v1 Adapter co-edit and live in one ticket.
+
+      **Split one ticket into N only when BOTH conditions hold:**
+      - **(P) Parallel sub-process potential** — N phase-subagents dispatched simultaneously; Target Files disjoint across all phases of each ticket; no Deps edge among the N.
+      - **(C) Context budget overflow** — combined cascade Rules + Spec References + Target Files exceed comfortable single-context for one phase-subagent's phase.
+
+      **NOT a reason to split:** audit milestone granularity (audit runs once per ticket regardless of size); logical layering (Port + Adapter ship together); partial shippability (consumer can't pick a half-module); human time-units (hours / days — irrelevant for AI execution bounded by context window).
+
+      Sequential split (A → B with hard Deps) without (C) = pure overhead: B's phase-subagent re-reads what A's already loaded; zero wall-clock gain.
+
+      Cross-scope: scope B DONE before A's tasks consuming B's outputs. Bootstrap tickets DONE before non-bootstrap of the same scope.
+    </Axiom>
+
+    <Axiom id="AX_BOOTSTRAP_TICKET_DERIVATION">
+      **Bootstrap Requirements rows with Owner=`this-scope-task` aggregate into the minimum number of tickets per `AX_DAG_AND_TICKET_BOUNDARIES`.** Default — group by Resolution affinity (all `package` rows → one «install deps» ticket; all `structural` rows editing the same config file → one ticket); subdivide only when (P) parallel-executable or (C) context overflow. Source: scope spec Bootstrap Requirements (infrastructure 9, contracts 7, library 8, product 8).
+      - Rows with Owner=`external-prereq-scope` → cross-scope dependency edge, not a ticket here.
+      - Rows with Owner=`operator-action` → noted in tracker index as a blocking external prerequisite, not a ticket.
+      - Bootstrap tickets must be DONE before any non-bootstrap ticket of the same scope (e.g. `install package` precedes `wire config that uses package`).
+      - Bootstrap tickets carry Verification populated from the Resolution column (e.g. `npm ls <pkg>` exit 0).
+      - If Bootstrap Requirements is absent from the spec → abort with `H_BOOTSTRAP_REQUIREMENTS_MISSING` (the spec did not pass discovery STEP_7).
+    </Axiom>
+
+    <Axiom id="AX_TICKET_HAS_BDD_AND_TESTS">
+      **Ticket carries BDD scenarios mapped to concrete tests.**
+
+      - Acceptance Criteria = strict BDD (Given/When/Then) translated from DbC pre/post + Requirements & Constraints + Decision Log. Negative scenarios, fallbacks, trust boundaries, platform limits pulled from spec, not inferred from component name.
+      - Each scenario gets a verification level marker: `contract` | `unit` | `integration` | `e2e`.
+      - Each scenario maps to `<test-file>::<canonical case name>` in section 6 Test Scenario Coverage, OR explicit `Deferred Test Ownership: <task-id>`.
+      - At least one phase of kind `test` MUST exist whose Target Files contains the test file, unless every scenario has `Deferred Test Ownership`.
+      - Canonical case names are normative: phase-subagent uses verbatim or updates the ticket before phase DONE.
+      - BDD describes behavior, not language-specific syntax.
+      - For every DbC contract in Spec References (Port / Adapter / Value Object / branded type / discriminated union): one `contract`-level typing scenario MUST exist — covers input/output shape, branded-type rejection at boundary, union exhaustiveness. `Deferred Test Ownership` not allowed for typing scenarios — they ship with the types.
+    </Axiom>
+
+    <Axiom id="AX_DONE_REQUIRES_EVIDENCE">
+      A Round cannot close (`[x] DONE` on the ticket) until ALL of:
+      - verification commands executed; result + exit code recorded in Execution Log;
+      - every BDD scenario has `<file>::<case>` confirmed OR deferred owner recorded;
+      - every entity introduced beyond module Entity Inventory logged as `Introduced <Name> because <reason>`;
+      - `Runtime Backing` honestly recorded; `real-runtime` claim without real implementation requires explicit `Deferred Runtime Scope`.
+    </Axiom>
+
+    <Axiom id="AX_TICKET_DEDUPLICATION">
+      **Project-wide content lives ONCE in `tasks/README.md`.** Declared there: file-header convention, baseline Completion Rule, Execution Log template, post-task audit hint. Per-scope Cascade Table lives in `tasks/<scope>/README.md`. Per ticket: only task-specific Meta, BDD, Test Scenario Coverage, Completion additions (if any), Execution Log instance (initially empty plan).
+    </Axiom>
+
+    <Axiom id="AX_TASK_ID_UNIQUENESS">
+      **`TSK-NN` is project-wide unique, sequential, immutable.**
+
+      - Before generating a ticket, scan `tasks/**/*.task-*.md` for collisions.
+      - ID never changes — even if ticket file moves between scopes.
+      - Code references via file headers point to IDs, not paths.
+      - Auditor cross-checks via `AX_TASK_ID_INTEGRITY`.
+      - Collision = abort; operator resolves.
+    </Axiom>
+
+    <Axiom id="AX_REOPEN_TICKET_FORMAT">
+      **Reopens accumulate as appended Rounds in one ticket; never spawn parallel tickets for same scope.**
+
+      - Meta `Reopens: <count> (<YYYY-MM-DD> — <last reason>)` on a single line; field omitted when 0.
+      - Status returns to `[~] IN_PROGRESS`; no separate `REOPENED`.
+      - Execution Log structured by `### Round N — <date>, <reason>`, append-only. Old Rounds NEVER edited.
+      - Re-runs are governed by `sdd-execute` orchestrator: audit FAIL triggers a `fix`-kind re-run of ONLY the phases whose Target Files contain finding locations. Phases not flagged are NOT re-run.
+    </Axiom>
+
+    <Axiom id="AX_EXECUTION_LOG_PLAN_VS_FACT">
+      **Scaffolding writes a MINIMAL skeleton; phase-subagent appends event lines as work happens.**
+
+      - **SKELETON** for Round 1 = under `### Round 1 — <date>, initial`, one `#### P<N>` block per phase declared in section 2 Phases Overview. Each block contains ONLY the closing lines:
+        ```
+        #### P<N>
+        - [ ] `<ts>` ver <cmd from section 5> → <pass|fail> exit=<code>
+        - [ ] `<ts>` DONE
+        ```
+        No pre-filled `file` / `test` / `cov` / `rules` / `recon` / `sync` lines — those were noise (duplicated Target Files / section 6 / Rules: list / git diff). Event lines (`intro` / `decision` / `tried` / `discovery` / `insight` / `verified` / `BLOCKED`) are APPENDED by the phase agent only when the event actually happens.
+      - **FACT** = the closing `[x]` lines have placeholders replaced with real values; preceding event lines exist only if their event happened.
+      - Each phase block ends with `**Handoff →** artifacts: [...]; decisions: [...]; open: [...]` line.
+      - Round closes with `#### Round close` block (single `DONE`) emitted by orchestrator after the last phase.
+      - **Forbidden**: `[x]` line containing any unreplaced `<…>` literal = fabricated done.
+      - Append-only by Rounds.
+
+      A trivial phase with no surprises has 2 lines (`ver`, `DONE`) + Handoff. A phase with real engineering content (decisions, discoveries, intros) has those lines too — but they earn their place by carrying information that isn't elsewhere.
+    </Axiom>
+
+    <Axiom id="AX_FILE_HEADER_TASK_TRACEABILITY">
+      **Files carry a unified file-header contract; IDs only, never paths; append-only for `@tasks`.**
+
+      Required file-level fields in execution profile:
+      - `@file` — mandatory; what the file holds.
+      - `@consumers` — mandatory; one or more consumers (see `AX_CONSUMERS_TAG_SEMANTICS`).
+      - `@tasks` — mandatory; associated `TSK-NN` list.
+
+      Canonical header shape:
+      ```
+      // @file: <what the file holds>
+      // @consumers: <consumer-1, consumer-2, ...>
+      // @tasks: TSK-04, TSK-12
+      ```
+    </Axiom>
+
+    <Axiom id="AX_CONSUMERS_TAG_SEMANTICS">
+      `@consumers:` names the entity (class, function, interface) that depends on this file's primary exports — not a file path, not a folder name. Name MUST match the consuming entity as named in the spec.
+    </Axiom>
+
+    <Axiom id="AX_CROSS_SCOPE_TASK_PLACEMENT">
+      Cross-scope integration tasks belong to the scope that **initiates or owns** the integration. If both sides have equal weight, create a dedicated `integration` scope in the Scope Graph and register it in `specs/README.md`. Never scatter pieces of one integration across multiple scope folders. `tasks/_integration/` is deprecated — do not create it.
+    </Axiom>
+
+    <Axiom id="AX_AUDIT_HOOK">
+      Round is complete only after `audit` returns PASS. `sdd-execute` orchestrator dispatches audit-subagent automatically after the last phase of a Round closes — operator does not invoke audit manually. `[x] DONE` on the ticket is mechanical close, not verification. Until audit PASS, dependents are blocked.
+    </Axiom>
+
+    <Axiom id="AX_PHASES_DECLARED_IN_HEADER">
+      Every ticket declares its work as an ordered list of phases in `## 2. Phases Overview` (compact table) and `## 3. Phases` (block per phase). Phase kinds are a closed vocabulary: `bootstrap | impl | test | config | doc | refactor`. (`fix` is reserved for re-runs at execution time, not for scaffolding.)
+
+      One phase = one focused unit of work for one subagent. Cross-phase dependencies (`Deps:`) are explicit. The orchestrator dispatches phases sequentially; the phase-subagent reads ONLY its phase's block, its phase's Rules, and prior-phase Handoff payloads.
+
+      Phase emission rules during scaffolding:
+      - Default mapping per Target Files content:
+        - production source files (e.g. `*.ts`, `*.py` excluding tests) → `impl` phase.
+        - test files (`*.test.*`, `*.spec.*`) → `test` phase, depends on the corresponding `impl`.
+        - third-party tool config files (`eslint.config.*`, `vitest.config.*`, `lefthook.yml`, etc.) → `config` phase.
+        - markdown docs → `doc` phase.
+        - package install + foundational config (from Bootstrap Requirements) → `bootstrap` phase, no Deps.
+        - trivial wiring files (module barrel `index.ts`, parent re-export update, single-line type-alias re-export) → NOT a separate ticket and NOT a separate phase. They are added to the `Target Files` of the `impl` phase that creates the symbols they re-export.
+      - Each phase carries its own `Rules:` list — subset of cascade-derived rules whose `<Triggers>` apply to its file class.
+      - Each phase carries its own `Target Files:` bullet list (NO ticket-level `Target Files` outside phases).
+      - Each phase carries `Inputs:` (`none` or list of prior phase IDs whose Handoff it consumes) and `Exit:` (one-line verifiable criterion).
+
+      Forbidden: emitting a ticket without `## 2. Phases Overview` and `## 3. Phases`; collapsing impl + test into one phase (they have different rule sets and different verification commands); emitting Target Files at ticket level instead of per-phase.
+    </Axiom>
+
+    <Axiom id="AX_SSOT_TRACEABILITY">
+      **No contract duplication.** Tickets link to spec sections via Markdown anchors. Module spec for contracts/consumers/invariants; scope spec 4 only for cross-cutting constraints.
+    </Axiom>
+
+    <Axiom id="AX_DIALOGUE_DISCIPLINE">
+      - **Phase agreement.** Agent never closes a phase autonomously. Signal `STATUS=READY_TO_ADVANCE`; operator confirms. Emit Phase Progress every round.
+      - **Neutral + critical.** Operator asks to merge tasks, skip a test, accept low coverage → surface the risk, demand justification. No auto-agreement.
+      - **Confidence explicit.** LOW / MEDIUM / HIGH stated. Under LOW: do not lock the DAG, do not close TASK_GENERATION.
+      - **Context budget.** Long dialogues: top-3 questions; compact Phase Progress; do not repeat full DAG when 1–2 edges changed.
+    </Axiom>
+
+    <Axiom id="AX_DECISION_LOG_REQUIRED">
+      Non-default scaffolding choices (operator merges 3 tasks into 1, refuses deferred coverage, overrides cascade activation) → `D-NNN` entry in `tasks/README.md` Decision Log with rationale.
+    </Axiom>
+
+    <Axiom id="AX_OPERATOR_LANGUAGE">
+      **Directive prose (axioms, halt names, step procedures, contract identifiers, structural section headings) — English.**
+      **Operator-facing artifact prose and operator-facing messages — Russian.** Russian applies to:
+      - Ticket body text (Purpose, Description, BDD scenario content after `Given` / `When` / `Then`, Decision Log `Why` / `Risk`).
+      - README content (Decision Log entries, Notes, descriptions).
+      - Halt messages emitted to the operator.
+      - Phase Progress free-text fields.
+
+      English regardless of context: code paths, file names, axiom IDs (`AX_*`), Trace anchors, IDs (`TSK-NN` / `D-NNN` / `H_*`), severity / status tokens (`TODO` / `IN_PROGRESS` / `DONE` / `BLOCKED`), BDD keywords, verification-level tokens, runtime-backing tokens, structural section headings, field labels.
+    </Axiom>
+
+    <Axiom id="AX_STATELESS_ARTIFACT">
+      All DAG decisions, links, BDD, completion rules baked into Markdown. Downstream sessions start with no scaffolding history.
+    </Axiom>
+
+    <Axiom id="AX_TICKET_SECTION_NAMES_NORMATIVE">
+      Ticket sections are wrapped with `<!--SECTION:UPPER_SNAKE-->…<!--/SECTION:UPPER_SNAKE-->` markers (grammar: `extract-section.sh`). **Anchor names in `TASK_TICKET_STRUCTURE` are normative, NOT illustrative** — orchestrator (`sdd-execute`) and auditor query them by exact string (`extract <ticket> PHASE_P<N>`, `META`, `EXECUTION_LOG`, …). Renaming or omitting a templated anchor breaks programmatic dispatch. Each `### P<N>` phase block under `## 3. Phases` gets its own anchor (`PHASE_P1`, `PHASE_P2`, …); the `## 3. Phases` container itself is NOT wrapped — extraction is per-phase.
+    </Axiom>
+  </Belief_State>
+
+  <Golden_Example>
+    Concrete ticket — `tasks/backend/payments/payments.task-04.md`. **Pattern: one module-spec → one ticket.** Port + Adapter + Value Objects + module barrel co-edit and travel together. Phases inside the ticket separate `impl` vs `test` cascades. Names of rules in the Activation Plan are project-specific (driven by cascade); the directive itself is language-agnostic.
+
+    ```markdown
+    # Task: TSK-04 — Implement payments module
+
+    ## 1. Meta
+    - **Task-ID:** TSK-04
+    - **Status:** [ ] TODO
+    - **Purpose:** Реализовать модуль `payments` целиком: `PaymentGatewayPort` + `StripePaymentAdapter` + `PaymentRequest`/`TransactionId` Value Objects + module barrel; покрыть unit + integration тестами.
+    - **Scope:** `backend`
+    - **Module:** `payments`
+    - **Dependencies:** TSK-01, TSK-03
+    - **Spec References:**
+      - Module spec: [payments](../../../specs/backend/payments/payments.spec.md)
+      - Contract: [`PaymentGatewayPort`](../../../specs/backend/payments/payments.spec.md#paymentgatewayport)
+      - Adapter: [`StripePaymentAdapter`](../../../specs/backend/payments/payments.spec.md#stripepaymentadapter)
+      - Consumer: [`OrderProcessor`](../../../specs/backend/orders/orders.spec.md#orderprocessor)
+    - **Runtime Backing:** `real-runtime`
+    - **Verification Levels:** `unit`, `integration`
+    - **Deferred Runtime Scope:** None
+
+    ## 2. Phases Overview
+    | ID | Kind | Deps | Status |
+    |----|------|------|--------|
+    | P1 | impl | —    | [ ]    |
+    | P2 | test | P1   | [ ]    |
+
+    ## 3. Phases
+
+    ### P1 — impl
+    - **Objective:** реализовать Port + Adapter + Value Objects + module barrel в одной impl-фазе (один phase-subagent context).
+    - **Rules:**
+      - [typescript-rules](../../../ai/directives/coding/typescript-rules.xml)
+      - [ports-adapters](../../../ai/directives/architecture/ports-adapters.xml)
+    - **Target Files:**
+      - `src/payments/ports/payment-gateway-port.ts`
+      - `src/payments/value-objects/payment-request.ts`
+      - `src/payments/value-objects/transaction-id.ts`
+      - `src/payments/adapters/stripe-payment-adapter.ts`
+      - `src/payments/index.ts`               <!-- trivial wiring lives here, not a separate phase -->
+    - **Inputs:** none
+    - **Exit:** typecheck pass; ports-adapters compliance; intro-discipline honored; `import { PaymentGatewayPort } from '@/payments'` resolves through module barrel.
+
+    ### P2 — test
+    - **Objective:** unit + integration tests против контракта `PaymentGatewayPort` и `StripePaymentAdapter`.
+    - **Rules:**
+      - [node-test](../../../ai/directives/testing/node-test.xml)
+    - **Target Files:**
+      - `src/payments/adapters/stripe-payment-adapter.test.ts`
+      - `src/payments/ports/payment-gateway-port.contract.test.ts`
+    - **Inputs:** P1 handoff
+    - **Exit:** все BDD-сценарии из section 4 покрыты; tests pass
+    ```
+
+    **Anti-pattern (forbidden):** splitting this into `TSK-04 Port + VOs`, `TSK-05 Adapter`, `TSK-06 module barrel`. Sequential split (each depends on prior) without (C) context overflow = pure sub-process overhead per `AX_DAG_AND_TICKET_BOUNDARIES`.
+  </Golden_Example>
+
+  <Halt_Conditions>
+    | 🛑 ID | Trigger |
+    |---|---|
+    | `H_NO_SPECS` | No specs/README.md or no scope specs found |
+    | `H_AMBIGUOUS_MODE` | `tasks/` present + intake unclear |
+    | `H_INCOMPLETE_SCOPE_SPEC` | Scope spec present but Discovery/required sections incomplete |
+    | `H_MISSING_RULES` | Any cascade source OR transitive `<Depends_On>` references a missing rule file |
+    | `H_RULES_CYCLE` | Transitive `<Depends_On>` closure encounters a cycle between rule files |
+    | `H_ID_COLLISION` | Generated `TSK-NN` collides with existing |
+    | `H_OPERATOR_REJECT` | Operator refuses Cascade Table / DAG / batch / final review |
+    | `H_LOW_CONFIDENCE` | Confidence LOW at DAG or task generation |
+    | `H_VERIFICATION_COMMAND_MISSING` | RequiresVerification alias not found in infra-spec Verification Commands |
+    | `H_BOOTSTRAP_REQUIREMENTS_MISSING` | Scope spec lacks Bootstrap Requirements section (spec did not pass discovery STEP_7) |
+    | `H_TYPING_SCENARIO_MISSING` | A contract in Spec References has no `contract`-level typing scenario in section 4 per `AX_TICKET_HAS_BDD_AND_TESTS` |
+  </Halt_Conditions>
+
+  <Execution_Plan>
+    <Step id="STEP_0_INTAKE">
+      <Goal>Read Specs Portal → detect scopes and graph (`AX_SCOPE_GRAPH_DETECTION`) → detect mode (`AX_MODE_AUTO_DETECT_OR_HALT`).</Goal>
+      <Action>
+        1. Emit TRACE_HEADER (STACK `ROOT__INTAKE`).
+        2. **Read `specs/README.md` Scope Graph as canonical entry point.** Portal absent → `H_NO_SPECS`. From Portal extract: all scope names + types + depends-on edges (Mermaid graph + Scopes table).
+        3. For each scope with ✅ status, read `specs/<scope>/<scope>.spec.md`.
+        4. For each product/library scope with 8 Module Map, read module specs.
+        5. Scope graph detection per `AX_SCOPE_GRAPH_DETECTION`. All absent → `H_NO_SPECS`.
+        6. Mode detection per `AX_MODE_AUTO_DETECT_OR_HALT`. On `H_AMBIGUOUS_MODE` halt with operator question.
+        7. In `extend-dag`: read existing `tasks/README.md`, per-scope READMEs, ticket files; capture max `TSK-NN` and current DAG.
+        8. Proceed to STEP_1.
+      </Action>
+    </Step>
+
+    <Step id="STEP_1_STACK_RESOLUTION">
+      <Goal>Load rule registry. Verify all rule references resolve. Build per-scope Cascade Tables. Operator approval.</Goal>
+      <Action>
+        1. TRACE_HEADER (STACK `ROOT__STACK_RESOLUTION`).
+        2. **Read `ai/directives/knowledge.xml` in full.** This is the canonical rule registry — contains `<Triggers>`, `<SkipWhen>`, `<ActivationHint>`, `<RequiresVerification>` for every rule. Required before verifying refs and before building per-phase Rules lists in STEP_4. Read it now — do not defer.
+        3. For each scope: traverse depends-on edges (transitive closure) to compute traversed-scopes. Collect rule refs from all traversed-scopes + target-scope + modules (task-tier added in STEP_3).
+        4. For each ref, verify file existence under `ai/directives/<category>/<rule>.xml`. Any miss → `H_MISSING_RULES` (abort with explicit list).
+        5. Build per-scope Cascade Tables (Scope × Categories matrix; tier rows from graph).
+        6. Phase Progress + Approval Check. STOP.
+      </Action>
+    </Step>
+
+    <Step id="STEP_2_DAG">
+      <Goal>Build acyclic task DAG in topological implementation order.</Goal>
+      <Action>
+        1. TRACE_HEADER (STACK `ROOT__DAG`).
+        2. **Read Bootstrap Requirements of each in-scope spec.** Section missing in any spec being scaffolded → `H_BOOTSTRAP_REQUIREMENTS_MISSING` (spec did not pass discovery STEP_7; abort with the offending scope name). For each row:
+           - Owner=`this-scope-task` → produce a Phase 0 ticket per `AX_BOOTSTRAP_TICKET_DERIVATION` (`bootstrap-<kind>-<short-name>`); Verification populated from Resolution column.
+           - Owner=`external-prereq-scope` → add cross-scope dependency edge (already declared in Scope Dependencies; verify consistency).
+           - Owner=`operator-action` → record in tracker index as an external prerequisite blocking Phase 0.
+        3. Analyze Entity Inventory + Contracts + Inter-Module Dependencies per module spec. Cross-scope dependencies from scope graph edges.
+        4. Form post-bootstrap tickets per `AX_DAG_AND_TICKET_BOUNDARIES` (default: one per coherent spec unit — one ticket per module-spec for product/library; one ticket per discrete capability for infra/contracts). Subdivide only when (P) parallel-executable or (C) context overflow. Assign sequential `TSK-NN` (project-wide; bootstrap tickets numbered first).
+        5. Check: no cycles; no context-overflow tickets per (C); no missing prerequisites; every non-bootstrap ticket depends (transitively) on all bootstrap tickets of the same scope.
+        5. Phase Progress + Approval Check (Mermaid graph). STOP.
+      </Action>
+    </Step>
+
+    <Step id="STEP_3_INDEX_GENERATION">
+      <Goal>Write project tracker + per-scope trackers per TASKS_README_STRUCTURE + SCOPE_TASKS_README_STRUCTURE.</Goal>
+      <Action>
+        1. TRACE_HEADER (STACK `ROOT__INDEX_GENERATION`).
+        2. Write `tasks/README.md` per `TASKS_README_STRUCTURE`. Project-Wide Conventions declared ONCE here per `AX_TICKET_DEDUPLICATION`. No Cascade Table here.
+        3. Per scope: write `tasks/<scope>/README.md` per `SCOPE_TASKS_README_STRUCTURE` with per-scope Cascade Table.
+        4. If cross-scope integrations exist: create a dedicated `integration` scope entry in `specs/README.md` and write `tasks/integration/README.md`.
+        5. Phase Progress + Approval Check. STOP.
+      </Action>
+    </Step>
+
+    <Step id="STEP_4_TASK_GENERATION">
+      <Goal>Emit each ticket per `TASK_TICKET_STRUCTURE`. Project-wide content NOT duplicated.</Goal>
+      <Action>
+        For each task:
+        1. TRACE_HEADER (STACK `ROOT__TASK_GENERATION__<TASK_ID>`).
+        2. Verify ID uniqueness per `AX_TASK_ID_UNIQUENESS`. Collision → `H_ID_COLLISION`.
+        3. Decompose into phases per `AX_PHASES_DECLARED_IN_HEADER`. Compute scope-level cascade per `AX_RULES_CASCADE_RESOLUTION`; for each phase, derive `Rules:` list per `AX_RULE_ACTIVATION_PLAN` (per-phase filtering by Target Files + kind).
+        4. Determine ticket path:
+           - Scope-level task: `tasks/<scope>/<scope>.task-NN.md`.
+           - Module-level task: `tasks/<scope>/<module>/<module>.task-NN.md`.
+           - Cross-scope integration: `tasks/integration/<label>.task-NN.md`.
+        5. Draft section 4 BDD per `AX_TICKET_HAS_BDD_AND_TESTS`, including the mandatory `contract`-level typing scenario for each DbC contract in Spec References.
+        6. **BDD review pass — isolated subagent.** Dispatch ONE general-purpose subagent with clean context; inputs = module spec slice + contract anchors + Requirements & Constraints + draft section 4 only; question = «какие negative / corner / trust-boundary / failure-mode сценарии отсутствуют?». Merge approved candidates into section 4 + section 6; append the full reviewed checklist (merged / rejected with reason) to section 8 Decision Log. Out-of-scope proposals (new entities / phases / contracts) → rejected, surfaced to operator at STEP_5.
+        7. Validate every contract in Spec References has its typing scenario mapped to a real test file under a `test` phase of THIS ticket. Missing → `H_TYPING_SCENARIO_MISSING` (name offending contract).
+        8. Write ticket per `TASK_TICKET_STRUCTURE`.
+        9. Pre-fill section 7 Execution Log as PLAN per `AX_EXECUTION_LOG_PLAN_VS_FACT` — one `#### P<N>` block per phase declared in section 2 Phases Overview.
+        10. Phase Progress per batch + Approval Check. STOP.
+      </Action>
+    </Step>
+
+    <Step id="STEP_5_REVIEW">
+      <Goal>Final operator agreement.</Goal>
+      <Action>
+        TRACE_HEADER (STACK `ROOT__REVIEW`). List created files with traceability links. Approval Check. STOP.
+      </Action>
+    </Step>
+  </Execution_Plan>
+
+  <Frame_Rules>
+    <Rule id="FRAME_PUSH_WHEN">Open nested frame on disputes about granularity, order, BDD scenarios, deferred coverage, per-task detail.</Rule>
+    <Rule id="FRAME_POP_WHEN">Close on confirmed conclusion, deferred status, or when local discussion cannot advance.</Rule>
+    <Rule id="FRAME_STATUS_VALUES">OPEN | BLOCKED | READY_TO_RETURN | READY_TO_ADVANCE | DEFERRED.</Rule>
+  </Frame_Rules>
+
+  <Output_Contracts>
+    <Contract id="TRACE_HEADER_FORMAT">
+      ```text
+      📋 TS_R<N> | STACK: ROOT__<FRAME>__<SUBFRAME> | FRAME: F_<KEY>_R<N> | <📂|🚧|↩️|⏭️|💤> <STATUS> | CONF: <LOW|MEDIUM|HIGH>
+      🎯 GOAL: <local goal>
+      ⏭️ EXIT: <exit condition>
+      ```
+    </Contract>
+
+    <Contract id="PHASE_PROGRESS_FORMAT">
+      ```markdown
+      🎯 Phase Progress — <STEP_NAME>
+        ✅ Closed:    <agreed>
+        ⏳ Open:      <under discussion>
+        🛑 Blocking:  <if any, else —>
+        ▶️ Next:      <proposal>
+        📊 Counters:  <e.g. "DAG: 18 tasks across 3 scopes; 14/18 tickets generated">
+      ```
+    </Contract>
+
+    <Contract id="TASK_TICKET_STRUCTURE">
+      Anchor names in this template are normative per `AX_TICKET_SECTION_NAMES_NORMATIVE`. Project-wide content (file-header rule, baseline Completion Rule, Execution Log protocol, audit hint) lives in `tasks/README.md` per `AX_TICKET_DEDUPLICATION` — NOT duplicated here.
+
+      ```markdown
+      # Task: <Task-ID> — <Task Title>
+
+      <!--SECTION:META-->
+      ## 1. Meta
+      - **Task-ID:** <TSK-NN>
+      - **Status:** [ ] TODO   <!-- [ ] TODO | [~] IN_PROGRESS | [x] DONE | [!] BLOCKED -->
+      - **Purpose:** <semantic goal one-liner>
+      - **Scope:** <scope-name>
+      - **Module:** <module-name or N/A>
+      - **Dependencies:** <comma-separated Task-IDs or None>
+      - **Reopens:** <count> (<YYYY-MM-DD> — <last reason>)   <!-- omit when 0 -->
+      - **Spec References:**
+        - Contract: [<ContractName>](<spec anchor>)
+        - Consumer: [<ConsumerName>](<spec anchor>)
+        - Constraints (if applicable): [<ScopeSpec section 4>](<path>)
+      - **Runtime Backing:** `not-implemented` | `simulation` | `real-runtime`
+      - **Verification Levels:** subset of `contract` | `unit` | `integration` | `e2e`
+      - **Deferred Runtime Scope:** None | <description>
+      <!--/SECTION:META-->
+
+      <!--SECTION:PHASES_OVERVIEW-->
+      ## 2. Phases Overview
+      | ID | Kind     | Deps | Status |
+      |----|----------|------|--------|
+      | P1 | <kind>   | —    | [ ]    |
+      | P2 | <kind>   | P1   | [ ]    |
+
+      <!-- Status set per phase by phase-subagent at end of phase. Orchestrator reads this table for planning. -->
+      <!--/SECTION:PHASES_OVERVIEW-->
+
+      ## 3. Phases
+
+      <!--SECTION:PHASE_P1-->
+      ### P1 — <kind>
+      - **Objective:** <one-line description>
+      - **Rules:**
+        - [ai/directives/<category>/<rule>.xml](<relative-path>)
+        - [ai/directives/<category>/<rule>.xml](<relative-path>)
+      - **Target Files:**
+        - <path>
+        - <path>
+      - **Inputs:** none   <!-- or "P0 handoff" / "P0, P1 handoffs" -->
+      - **Exit:** <verifiable criterion, e.g. "typecheck pass; ports-adapters compliance">
+      <!--/SECTION:PHASE_P1-->
+
+      <!--SECTION:PHASE_P2-->
+      ### P2 — <kind>
+      - **Objective:** <one-line>
+      - **Rules:**
+        - [ai/directives/<category>/<rule>.xml](<relative-path>)
+      - **Target Files:**
+        - <path>
+      - **Inputs:** P1 handoff
+      - **Exit:** <verifiable criterion>
+      <!--/SECTION:PHASE_P2-->
+
+      <!--SECTION:BDD-->
+      ## 4. Acceptance Criteria (BDD)
+      Contract: see Spec References.
+
+      **Feature:** <component behavior>
+
+      **Scenario:** <name> [`<verification level>`]
+      - **Given** <precondition>
+      - **When** <command/query>
+      - **Then** <postcondition>
+      - **And** <side effect>
+      <!--/SECTION:BDD-->
+
+      <!--SECTION:VERIFICATION-->
+      ## 5. Verification
+      | Command | Required by |
+      |---------|-------------|
+      | <resolved invocation> | <rule-id>, <rule-id> |
+
+      <!-- One row per unique Verification Commands alias from infra-spec. Multiple rules
+           sharing check-command produce a single row. Phase-subagent runs only the rows
+           whose Required-by overlaps with its phase's Rules list. -->
+
+      - **Task-specific Completion additions:** <list or "none beyond project baseline">
+      <!--/SECTION:VERIFICATION-->
+
+      <!--SECTION:TEST_COVERAGE-->
+      ## 6. Test Scenario Coverage
+      - Scenario <name> → `<test-file>` :: `<canonical case name>`
+      <!--/SECTION:TEST_COVERAGE-->
+
+      <!--SECTION:EXECUTION_LOG-->
+      ## 7. Execution Log
+      *(Round = one execute-then-audit attempt. Per-phase blocks within a Round. Skeleton is minimal — event lines (`intro` / `decision` / `tried` / `discovery` / `insight` / `BLOCKED`) appear ONLY when the event happens. Token vocabulary in [tasks/README.md#execution-log-template](../../README.md#execution-log-template).)*
+
+      ### Round 1 — <YYYY-MM-DD>, initial
+      <!-- Skeleton pre-filled: only the closing ver + DONE lines per phase. Phase agent
+           prepends event lines as decisions/discoveries/intros/problems actually happen. -->
+
+      #### P1
+      - [ ] `<ts>` ver `<cmd>` → `<pass|fail>` exit=`<code>`
+      - [ ] `<ts>` DONE
+      **Handoff →** artifacts: [...]; decisions: [...]; open: [...]
+
+      #### P2
+      - [ ] `<ts>` ver `<cmd>` → `<pass|fail>` exit=`<code>`
+      - [ ] `<ts>` DONE
+      **Handoff →** artifacts: [...]; decisions: [...]; open: [...]
+
+      <!-- After last phase, orchestrator appends Round close: -->
+      #### Round close
+      - [ ] `<ts>` DONE
+      <!--/SECTION:EXECUTION_LOG-->
+
+      <!-- AUDIT_ROUNDS section appended ONLY after first reopen-triggering audit, per audit AX_REOPEN_ROUNDS_IN_TICKET. Anchor format: -->
+      <!--   <!--SECTION:AUDIT_ROUNDS--> -->
+      <!--   ## Audit Rounds -->
+      <!--   …(per TICKET_AUDIT_ROUND_FORMAT in audit.directive.xml) -->
+      <!--   <!--/SECTION:AUDIT_ROUNDS--> -->
+      ```
+    </Contract>
+
+    <Contract id="TASKS_README_STRUCTURE">
+      Project-level tracker. High-level DAG = cross-scope edges only; intra-scope edges live in scope READMEs. No Cascade Table here.
+
+      ```markdown
+      # Project Tasks
+
+      ## Entry Points
+      - [Specs Portal](../specs/README.md) — Scope Graph + all scope specs.
+      - Tickets are executed ONLY via `sdd-execute` SKILL (single ticket) or `sdd-execute-batch` SKILL (queue). The orchestrator dispatches phase-subagents per ticket's Phases Overview, then `sdd-audit` automatically — operator does not invoke audit manually.
+
+      ## Project-Wide Conventions
+
+      ### File-header Convention
+      Per `AX_FILE_HEADER_TASK_TRACEABILITY` — canonical format, rules, and lang-agnostic note defined there.
+
+      ### Completion Rule (baseline)
+      A task cannot transition to `[x] DONE` until ALL of (per `AX_DONE_REQUIRES_EVIDENCE`):
+      1. Every phase declared in section 2 Phases Overview has Status `[x]`.
+      2. Every BDD scenario mapped to test ownership in section 6 OR has `Deferred Test Ownership: <task-id>`.
+      3. Verification commands relevant to each phase executed; results + exit codes recorded in that phase's Execution Log block.
+      4. Canonical case names match real test cases or ticket updated.
+      5. `Deferred Runtime Scope` recorded if applicable.
+      6. Every introduced-beyond-Inventory entity logged as `<ts> intro <Name> ← <reason>` in the relevant phase block.
+      7. Every phase block ends with a typed **Handoff →** line.
+
+      Task-specific additions live in each ticket's section 5.
+
+      ### Execution Log Template
+      Canonical token vocabulary (single source of truth; phase-protocol and audit reference this table, do not redefine):
+
+      | Token | Tail | Mandatory when |
+      |---|---|---|
+      | `intro` | `<Entity> ← <reason>` | new entity appears in code beyond module Entity Inventory |
+      | `decision` | `<key>=<value> ← <reason>` | typed choice that affected output |
+      | `tried` | `<approach> → <result>` | approach attempted then abandoned (failed path worth recording) |
+      | `discovery` | `<fact>` | reality diverged from spec / assumption |
+      | `insight` | `<observation> → <spec-section>, <change>` | spec gap detected |
+      | `verified` | `<tool>@<version> <summary>` | `config` kind: third-party API confirmed |
+      | `ver` | `<cmd> → pass|fail exit=<N>` | once per phase, closing run (always present) |
+      | `BLOCKED` | `<cause>` | phase ended `[!] BLOCKED` |
+      | `DONE` | (no tail) | terminal line of phase or Round close (always present) |
+
+      Round structure:
+      ```markdown
+      ### Round <N> — <YYYY-MM-DD>, <reason>
+
+      #### P1
+      <!-- event lines (0+, from the table above) appended as events happen -->
+      - [x] `<ts>` ver <cmd> → pass exit=0
+      - [x] `<ts>` DONE
+      **Handoff →** artifacts: [...]; decisions: [...]; open: [...]
+
+      #### Round close
+      - [x] `<ts>` DONE
+      ```
+
+      Trivial phase with no events → 2 lines (`ver` + `DONE`) + Handoff. Padding with empty lines is forbidden.
+
+      ⛔ `[x]` line with any unreplaced `<…>` literal = fabricated done → `EXECUTION_LOG_INCOMPLETE` (BLOCKER).
+
+      ### Post-task Hook
+      Per `AX_AUDIT_HOOK`. After last phase of a Round closes, the orchestrator dispatches `sdd-audit`. Until audit returns PASS, Round is closed-but-unverified and dependents are blocked.
+
+      ## High-Level DAG
+      Cross-scope edges + integration tickets only. Intra-scope DAGs live in per-scope READMEs.
+
+      ```mermaid
+      graph TD
+        backend --> infra-base
+        web --> infra-base
+        web --> backend
+        TSK-13[Cross-scope integration] -.-> web
+      ```
+
+      ## Tracker Index
+      | Scope | Type | Tracker | Tasks | Done |
+      |---|---|---|---|---|
+      | infra-base | infrastructure | [README](infra-base/README.md) | 6 | 0/6 |
+      | api-contracts | contracts | [README](api-contracts/README.md) | 2 | 0/2 |
+      | backend | product | [README](backend/README.md) | 12 | 0/12 |
+      | web | product | [README](web/README.md) | 8 | 0/8 |
+      | integration | integration | [README](integration/README.md) | 1 | 0/1 |
+
+      ## Decision Log (task-scaffolding-level)
+      [D-NNN entries when operator made non-default choices.]
+      ```
+    </Contract>
+
+    <Contract id="SCOPE_TASKS_README_STRUCTURE">
+      Per-scope tracker at `tasks/<scope>/README.md`. Contains Cascade Table (derived from scope graph) + intra-scope DAG + Tracker.
+
+      ```markdown
+      # Tasks: <scope-name>
+
+      ## Scope Spec
+      - [Scope spec](../../specs/<scope>/<scope>.spec.md)
+
+      ## Cascade Table
+      Effective rules for tasks in this scope. Derived from scope graph (depends-on transitive closure).
+
+      Tier order (low → high priority on collision): `traversed-scopes` → `target-scope` → `module:<name>` → `task`.
+
+      | Tier | coding | testing | architecture | infra |
+      |------|--------|---------|--------------|-------|
+      | infra-base (traversed) | typescript-rules | vitest-rules | | eslint-setup, git-setup, nodejs-npm-setup |
+      | api-contracts (traversed) | | | | |
+      | <scope-name> (target) | | | ports-adapters | |
+      | module:payments | | node-test | | |
+
+      ### Rule Sources
+      - Traversed scopes: [scope graph](../../specs/README.md)
+      - Target scope: [<scope> spec 5/4.5](../../specs/<scope>/<scope>.spec.md)
+      - Module: each module's 9 Handoff
+      - Files: `ai/directives/<category>/<rule>.xml`
+
+      ## Intra-Scope DAG
+      ```mermaid
+      graph TD
+        TSK-04 --> TSK-05
+        TSK-06 --> TSK-04
+      ```
+
+      ## Tracker
+      | Task-ID | Title | Module | Dependencies | Status | Reopens |
+      |---------|-------|--------|--------------|--------|---------|
+      | [TSK-04](payments/payments.task-04.md) | Implement StripePaymentAdapter | payments | TSK-01, TSK-03 | `[ ]` TODO | 0 |
+
+      ## Notes
+      [Optional: scope-specific execution notes, deviations, deferred items.]
+      ```
+    </Contract>
+  </Output_Contracts>
+
+</SddTaskScaffolding>