gennady 0.8.3 → 0.8.4-draft.2

package/ai/kit/templates/sdd-v2/amplify-security.directive.hbs

@@ -0,0 +1,70 @@
+<SddAmplifySecurity keywords="security, amplify, threat-model, trust-boundaries, authn, authz, secrets, input-validation, pii, data-classification, sca, sdd-amplify-security" type="directive" ver="2.0">
+  <Mission>
+    Deepen the security posture of a scope spec under discovery — threat model lite: trust
+    boundaries, authn/authz model, secrets handling, input validation at external boundaries,
+    PII / data classification, dependency risk (delegated to SCA tooling). Loaded lazily by the
+    discovery interview's triage when the scope touches external input, user accounts, or
+    sensitive data; inherits the session core (language, dialogue, safeguard, no-narration) — not
+    repeated here.
+
+    Input — the scope spec draft + interview context. Output — a filled `Security` subsection
+    inside Requirements & Constraints (`SECURITY_SECTION_FORMAT`) + follow-up items appended to
+    the discovery interview map. Out of scope: pentest planning, infra hardening runbooks — the
+    spec records decisions, not procedures.
+  </Mission>
+
+  <BeliefState deps="AX_OPERATOR_LANGUAGE, AX_OPERATOR_SAFEGUARD, AX_NO_PROCESS_NARRATION">
+    {{> "axiom/process/ax-amplify-defaults-first"}}
+
+    {{> "axiom/spec/ax-decision-log-required"}}
+
+    {{> "axiom/spec/ax-external-input-untrusted"}}
+
+    {{> "axiom/infra/ax-secrets-discipline"}}
+  </BeliefState>
+
+  <HaltConditions>
+    | 🛑 ID | Trigger |
+    |---|---|
+    | `H_NO_SECURITY_SURFACE` | Triage misfired: no trust boundary, no stored user data — report and return control |
+    | `H_OPERATOR_REJECTS_DEFAULTS` | Operator declines the whole defaults package and skips deep-dive — leave the spec untouched |
+  </HaltConditions>
+
+  <ExecutionPlan>
+    <Step id="STEP_0_PROPOSE_DEFAULTS">
+      <Goal>Assemble the security defaults package for this product class.</Goal>
+      <Action>
+        From the spec draft, map the attack surface: trust boundaries, entry points, stored data
+        classes. Per `AX_AMPLIFY_DEFAULTS_FIRST`, draft one default decision per topic — boundaries
+        + validation (per `AX_EXTERNAL_INPUT_UNTRUSTED`), authn/authz model, secrets handling (per
+        `AX_SECRETS_DISCIPLINE`), PII classification, SCA delegation — grounded in what live
+        products of this class ship; short targeted research when class practice is uncertain.
+        Zero surface found → `H_NO_SECURITY_SURFACE`.
+      </Action>
+    </Step>
+    <Step id="STEP_1_AGREE">
+      <Goal>One accept-or-edit gate; deep-dive only on explicit pick.</Goal>
+      <Action>
+        Present the package as ONE reply per `AX_AMPLIFY_DEFAULTS_FIRST` (AskUserQuestion when
+        available, else `QUESTION_FORMAT`); each topic accept / edit / deep-dive. For topics the
+        operator marks deep-dive, interview by the topic map: boundaries → authn/authz → secrets →
+        validation → PII → dependencies. Untouched topics keep their defaults. STOP.
+      </Action>
+    </Step>
+    <Step id="STEP_2_APPLY">
+      <Goal>Write the agreed decisions into the spec.</Goal>
+      <Action>
+        `READ_AND_USE_DIRECTIVE("ai/directives/sdd-v2/formats/security-section-format.xml")` and
+        write the `Security` subsection into Requirements & Constraints of the scope spec.
+        Non-default picks and notable accepted defaults → Decision Log per
+        `AX_DECISION_LOG_REQUIRED`. Topics left unresolved after deep-dive → items on the
+        discovery interview map. Return control to the interview.
+      </Action>
+    </Step>
+  </ExecutionPlan>
+
+  <ChatOutput>
+    Service line — dim, internal, never narrated (`AX_NO_PROCESS_NARRATION`):
+    `🛡️ AMP_SEC · topics=<n> · accepted=<n> · edited=<n> · dive=<n>`.
+  </ChatOutput>
+</SddAmplifySecurity>

package/ai/kit/templates/sdd-v2/amplify-storage.directive.hbs

@@ -0,0 +1,71 @@
+<SddAmplifyStorage keywords="storage, amplify, schema, indexes, access-patterns, migrations, retention, persistence, sdd-amplify-storage" type="directive" ver="2.0">
+  <Mission>
+    Deepen the storage model of a scope spec under discovery: schema shape, indexes, access
+    patterns, data migrations, retention. Loaded lazily by the discovery interview's triage —
+    ONLY for scopes with persistence; inherits the session core — not repeated here.
+
+    Input — the scope spec draft + interview context. Output — a `Storage Model` subsection
+    inside the Architecture section of the scope spec + follow-up items on the discovery
+    interview map. Out of scope: picking the database engine when the spec already locked it
+    (that is a pivot), DDL-level detail — the spec records the model, tickets carry the DDL.
+  </Mission>
+
+  <BeliefState deps="AX_OPERATOR_LANGUAGE, AX_OPERATOR_SAFEGUARD, AX_NO_PROCESS_NARRATION">
+    {{> "axiom/process/ax-amplify-defaults-first"}}
+
+    {{> "axiom/spec/ax-decision-log-required"}}
+
+    {{> "axiom/spec/ax-access-patterns-drive-schema"}}
+
+    {{> "axiom/spec/ax-data-lifecycle-explicit"}}
+  </BeliefState>
+
+  <HaltConditions>
+    | 🛑 ID | Trigger |
+    |---|---|
+    | `H_NO_PERSISTENCE` | Triage misfired: the scope stores nothing durable — report and return control |
+    | `H_OPERATOR_REJECTS_DEFAULTS` | Operator declines the whole defaults package and skips deep-dive — leave the spec untouched |
+  </HaltConditions>
+
+  <ExecutionPlan>
+    <Step id="STEP_0_PROPOSE_DEFAULTS">
+      <Goal>Assemble the storage defaults package for this product class.</Goal>
+      <Action>
+        From the spec draft, list the data the scope persists and — FIRST, per
+        `AX_ACCESS_PATTERNS_DRIVE_SCHEMA` — the named access patterns (queries, read/write mix,
+        cardinality, hot paths). No durable data → `H_NO_PERSISTENCE`. Per
+        `AX_AMPLIFY_DEFAULTS_FIRST`, draft one default decision per topic: schema shape serving
+        those patterns, index plan (one named query behind every index), migration policy (expand →
+        backfill → contract per `AX_DATA_LIFECYCLE_EXPLICIT`), retention per data class — grounded
+        in what live products of this class ship; short targeted research when class practice is
+        uncertain.
+      </Action>
+    </Step>
+    <Step id="STEP_1_AGREE">
+      <Goal>One accept-or-edit gate; deep-dive only on explicit pick.</Goal>
+      <Action>
+        Present the package as ONE reply per `AX_AMPLIFY_DEFAULTS_FIRST` (AskUserQuestion when
+        available, else `QUESTION_FORMAT`); each topic accept / edit / deep-dive. Deep-dive topic
+        map: access patterns → schema → indexes → migrations → retention. Untouched topics keep
+        their defaults. STOP.
+      </Action>
+    </Step>
+    <Step id="STEP_2_APPLY">
+      <Goal>Write the agreed storage model into the spec.</Goal>
+      <Action>
+        Write a `### Storage Model` subsection into the Architecture section of the scope spec:
+        **Access Patterns** (table `| Запрос | Частота | Read/Write | Hot? |`) → **Schema**
+        (entity sketch, intent-level) → **Indexes** (`| Индекс | Обслуживает запрос |`) →
+        **Migrations** (policy) → **Retention** (`| Данные | Срок | Механика удаления |`).
+        Non-default picks and notable accepted defaults → Decision Log per
+        `AX_DECISION_LOG_REQUIRED`. Unresolved topics → items on the discovery interview map.
+        Return control to the interview.
+      </Action>
+    </Step>
+  </ExecutionPlan>
+
+  <ChatOutput>
+    Service line — dim, internal, never narrated (`AX_NO_PROCESS_NARRATION`):
+    `🗄️ AMP_STO · topics=<n> · accepted=<n> · edited=<n> · dive=<n>`.
+  </ChatOutput>
+</SddAmplifyStorage>

package/ai/kit/templates/sdd-v2/audit.directive.hbs

@@ -0,0 +1,241 @@
+<SddAudit keywords="audit, drift-detection, closed-world, runtime-backing, insight-backflow, findings-routing, semantic, fresh-eyes, sdd-audit, yagni" type="directive" ver="2.4">
+  <Mission>
+    Verify that the code a Round produced matches its spec and ticket — and nothing more.
+    Dispatched fresh-eyes by the execute orchestrator after a Round closes (or run per-task / per-epic).
+    The mechanical layer is `sdd-check`; I add the SEMANTIC layer it cannot do — whether the implementation
+    satisfies the contract's MEANING, whether a `real-runtime` claim is actually backed, whether an introduced
+    entity is real drift — and route findings as neutral proposals. Findings only; routing only.
+
+    Input — task-id, round, the artifacts list (union of phase Handoff artifacts), the relevant spec
+    and ticket. Output — an ephemeral findings summary in chat; on a reopen-triggering round, an
+    appended Audit Rounds section in the ticket.
+
+    **Glossary.** Drift = code / ticket / spec disagree. Finding = a neutral, routed proposal — a
+    proposal, MUST stay a proposal. Modes: per-task · per-epic.
+  </Mission>
+
+  <BeliefState>
+    {{> "axiom/process/ax-operator-language"}}
+
+    {{> "axiom/process/ax-tool-invocation"}}
+
+    {{> "axiom/process/ax-operator-dialogue-style"}}
+
+    {{> "axiom/process/ax-read-per-manifest"}}
+
+    <Axiom id="AX_MECHANICAL_VIA_SDD_CHECK">
+      Deterministic mechanical checks are NOT hand-coded in this directive — they live in one tool, `sdd-check`, which the whole-tree reporter and this directive both consume. Single source of mechanical truth → no drift between the SDD reviewers. Take its findings as given; do NOT hand-redo them.
+
+      - `sdd-check --task <ticket-path>` → one ticket: section-anchor balance · Meta + Execution Log present · Task-ID / Status parseable · fabricated DONE · DONE-with-active-blocker · DONE-with-placeholders · phase graph (deps resolve + acyclic) · phase ↔ `PHASE_Pn` section coverage · DONE ⇒ every phase checked · **RULES_CASCADE_CLOSURE** (each phase's `Rules:` list is already the full transitive `<DependsOn>` closure — `SDD_RULES_CASCADE_UNRESOLVED`) · **BDD_COVERAGE** (Test Scenario Coverage canonical case names exist verbatim in their declared test file — `SDD_BDD_SCENARIO_UNTESTED`).
+      - `sdd-check --all [root]` → the whole tree, additionally: the task DAG (Task-ID collisions · unresolved dependencies · cycles) · tracker ↔ ticket coherence (status drift · missing rows · orphan rows) · spec-link resolution + spec-anchor balance · portal integrity (scope-graph acyclicity · graph↔table↔spec · orphan specs · dangling deps) — plus RULES_CASCADE_CLOSURE and BDD_COVERAGE per ticket, as above.
+      - `sdd-check --changed [root]` → changed source files: **TASKS_APPEND_ONLY** (`@tasks:` header never drops an id present at HEAD — `SDD_TASKS_APPEND_ONLY_REGRESSION`) · **CONSUMERS_RESOLVABLE** (`@consumers:` identifiers resolve elsewhere in the repo by text search — `SDD_CONSUMERS_UNRESOLVED`, warn-only: the search is crude, treat a hit as a lead, not a verdict).
+
+      `gennady yagni` (run as part of `sdd-verify --profile full`, STEP_1) is likewise taken as
+      given for its own two checks: usage count `< 2` (`ERR_CLI_YAGNI_UNDERUSED`) and, when the
+      Usage Waiver label cites a `D-NNN`, whether it resolves to a live Decision Log entry
+      (`ERR_CLI_YAGNI_WAIVER_DECISION_MISSING`) — do not re-count usages or re-search Decision Logs
+      by hand.
+
+      Audit owns only what the tool cannot decide mechanically: closed-world symbol diff (code↔inventory), stale-after-pivot, runtime-backing real-vs-stub, whether a phase's `Rules:` list matches what the cascade tiers would derive **now** (`AX_RULES_CASCADE_VERIFICATION` — re-deriving the plan is semantic; the tool only confirms the declared list is internally closed), and whether a gated yagni finding's contract label has a matching Execution Log line (`AX_AUDIT_YAGNI_CROSSCHECK` — a cross-artifact check the tool cannot do, since it only reads the contract and the Decision Log, never the Execution Log). File-header presence (`@file`/`@consumers`/`@tasks`) is checked by `sdd-verify`, not here.
+    </Axiom>
+
+    {{> "axiom/audit/ax-audit-reads-code"}}
+
+    {{> "axiom/audit/ax-git-diff-scan"}}
+
+    {{> "axiom/audit/ax-closed-world-primary-check"}}
+
+    {{> "axiom/audit/ax-rules-cascade-verification"}}
+
+    <Axiom id="AX_AUDIT_YAGNI_CROSSCHECK">
+      Every symbol `gennady yagni` reports as gated (a Usage Waiver present, per
+      `AX_MECHANICAL_VIA_SDD_CHECK`) MUST have both: (1) the `- **Usage Waiver:** <reason>` label
+      (or `D-NNN — <reason>` when a genuine Decision Log entry backs it) in its contract/surface
+      entry, (2) a `<ts> yagni <name> ← <reason>` line in the round's Execution Log
+      (`AX_USAGE_WAIVER_DISCIPLINE`). When the label cites a `D-NNN`, it must also resolve to a live
+      Decision Log entry — the tool confirms that; audit cross-checks (2) against (1), since they
+      are two different artifacts and the tool never reads the Execution Log. A label with no
+      matching log line is `YAGNI_WAIVER_INCOMPLETE` (`MAJOR`): indistinguishable from a
+      stale/copy-pasted label never actually decided during this round.
+    </Axiom>
+
+    {{> "axiom/audit/ax-runtime-backing-verification"}}
+
+    {{> "axiom/audit/ax-insight-backflow-capture"}}
+
+    <Axiom id="AX_LANGUAGE_QUALITY_CHECK">
+      Operator-facing prose of the audited artifacts (spec Vision / Requirements / Decision Log
+      bodies, ticket Purpose / Description, README text) must read as a technical document in flat
+      engineering Russian — clear to any engineer on the project, junior developer to architect to
+      security engineer. Two layers:
+      - **Deterministic pre-filter:** `sdd-check` already flags transliterated anglicisms
+        (`SDD_LANGUAGE_CALQUE`, warn) — treat every such warning as a finding to route, do not
+        re-judge the word list by hand.
+      - **Semantic judgment (this audit)** — style AND comprehension, two different failure modes:
+        - *Style:* literary or ornate register, English idioms translated word-for-word, sentences a
+          busy colleague would stumble on.
+        - *Comprehension* (deeper than style — a sentence can be flawless Russian and still be a
+          cipher): an **empty label** — an adjective+noun term with no stated opposite («тонкая
+          строка» — thin relative to what? is there a «толстая»?) — is unexplained jargon, not a
+          description; a **metaphor stated as fact** («у разговора есть дом») instead of the literal
+          mechanism («тред хранится как обычная строка ChatEntity») is rare but dangerous, since it
+          passes every other filter; a **term whose meaning lives only in code** must be decoded from
+          that code and restated in the sentence, never guessed and never left opaque.
+        Test both: read it aloud as a mid-level developer (style); then strip the term from your head
+        and ask whether you could still act on the sentence (comprehension) — either failure routes.
+
+      → `LANGUAGE_QUALITY` finding with the concrete sentence and a plain-Russian rewrite proposal.
+      Canonical tokens (code, IDs, status tokens, BDD keywords, paths) stay English per
+      `AX_OPERATOR_LANGUAGE` and are never flagged.
+    </Axiom>
+
+    {{> "axiom/audit/ax-drift-taxonomy"}}
+
+    {{> "axiom/audit/ax-severity-tagging"}}
+
+    {{> "axiom/audit/ax-findings-as-proposals"}}
+
+    <Axiom id="AX_FINDING_ROUTING">
+      Every finding is routed to the artifact that owns the remediation:
+
+      | Finding type | Action |
+      |---|---|
+      | `CLOSED_WORLD_DRIFT` | spec edit (add entity to Inventory) OR ticket reopen |
+      | `COMPLETENESS_GAP` | ticket reopen — new Round N |
+      | `RUNTIME_BACKING_VIOLATION` | spec edit (Deferred Runtime Scope) OR ticket reopen |
+      | `RULES_COMPLIANCE_VIOLATION` | ticket reopen, new Round N |
+      | `RULES_CASCADE_MISMATCH` | ticket update (per-phase `Rules:` list) |
+      | `BDD_COVERAGE_MISMATCH` | ticket reopen OR ticket update (canonical case names) |
+      | `EXECUTION_LOG_INCOMPLETE` | ticket update / reopen |
+      | `INSIGHT_BACKFLOW` | spec edit (scope or module spec) |
+      | `STALE_AFTER_PIVOT` | reopen / refine the affected downstream artifact |
+      | `TASK_ID_DRIFT` | code-fix via ticket reopen |
+      | `YAGNI_WAIVER_INCOMPLETE` | ticket update (add the missing Execution Log line) OR spec edit (remove the label if it was never actually decided) |
+      | `ENVIRONMENT_GATE_UNAVAILABLE` | operator escalation — NOT a phase fix and NOT something audit or the worker repairs itself; spin out as a separate infra/environment task if the fix is non-trivial |
+      | `DEAD_CODE_SUSPECT` (spotted incidentally during a probe) | spin out as a separate task (background task / new ticket) — never fixed inside the current task; keeps the current blast radius bounded |
+      | operator-acknowledged risk | Decision Log entry in the scope spec |
+
+      The audit agent proposes a concrete edit (diff or instruction). The operator decides and applies. The audit agent does not modify code autonomously (per `AX_NO_AUTO_FIX`).
+    </Axiom>
+
+    {{> "axiom/audit/ax-neutral-findings"}}
+
+    {{> "axiom/audit/ax-no-auto-fix"}}
+
+    {{> "axiom/audit/ax-ephemeral-output"}}
+
+    {{> "axiom/audit/ax-reopen-rounds-in-ticket"}}
+
+    {{> "axiom/audit/ax-audit-modes"}}
+  </BeliefState>
+
+  <HaltConditions>
+    | 🛑 ID | Trigger |
+    |---|---|
+    | `H_NOTHING_TO_AUDIT` | No completed Round / no committed code to compare |
+    | `H_SPEC_MISSING` | The spec the ticket references does not exist |
+  </HaltConditions>
+
+  <ExecutionPlan>
+    <Step id="STEP_1_MECHANICAL">
+      <Goal>Get the mechanical findings from the tool. Take them as given.</Goal>
+      <Action>
+        **Every dispatch of this step re-runs the full gate set below from scratch — R2 (or any later
+        round) is NOT permitted to reuse, skip, or "carry forward as still green" a gate result from a
+        prior round.** A prior round's PASS on a gate is stale the moment new code landed; only a gate
+        re-run in THIS dispatch may back a verdict.
+        Run `sdd-check --task <ticket-path>` (and `--all` for an epic, per `AX_AUDIT_MODES`) plus
+        `sdd-check --changed` per `AX_MECHANICAL_VIA_SDD_CHECK` — together they report the deterministic
+        findings: structure / anchors / Task-ID + Status, fabricated-DONE, the phase graph,
+        Execution-Log completeness, the task DAG, tracker↔ticket coherence, RULES_CASCADE_CLOSURE,
+        BDD_COVERAGE, TASKS_APPEND_ONLY, and CONSUMERS_RESOLVABLE. Take these as given — the tool owns
+        them. Then INDEPENDENTLY re-run the green gate — `sdd-verify --profile full`,
+        `gennady lint --spec=<module-spec>` (cast + closed-world inventory over the changed files), and
+        `gennady testcov --run --min=80` (coverage gate — project line coverage ≥ 80% at task completion):
+        Always re-derive the gate yourself rather than trust the worker's logged `ver` lines; a gate that fails
+        here, a `ver` logged for a command that does not actually pass, or coverage below the gate, is a `BLOCKER`.
+        A gate command that does not execute at all — no runner, missing script, no network, crashes before
+        producing a pass/fail — is a DIFFERENT case from a gate that runs and reports red: it is neither PASS
+        nor a failure to diagnose. Do NOT patch the environment yourself to make it run (that is the worker's
+        `AX_PERMITTED_BASH_COMMANDS` boundary re-purposed for the wrong actor, and it hides the real gap from
+        the operator). Record it as `ENVIRONMENT_GATE_UNAVAILABLE` and let STEP_3 route it. **PASS is never the
+        verdict when any gate is red OR any gate did not execute** — the only outcomes for a task with an
+        unexecuted gate are `FAIL` (with `phases_to_fix` left empty, since no phase can fix an environment
+        problem) or an explicit operator escalation; whole-task verdict computation MUST treat "gate did not
+        run" the same as "gate ran and failed" for this purpose.
+        When the audit closes a WHOLE module
+        (its last task — every sibling DONE), add the reverse closed-world sweep over the module's code root:
+        `gennady lint --spec=<module-spec> --inventory-reverse <module-code-dir>` — every entity declared in the
+        inventory must now be exported by some file (`ERR_CLI_LINT_INVENTORY_UNIMPLEMENTED` = declared-but-unbuilt
+        / renamed-away). Run it only at module close; for a single mid-module phase the per-phase diff is a subset
+        and would false-positive. Closed-world symbol diff, the cascade-tier re-derivation, and
+        stale-after-pivot belong to STEP_2 (semantic), not the tool.
+      </Action>
+    </Step>
+    <Step id="STEP_2_SEMANTIC">
+      <Goal>Add the layer the tool cannot — meaning.</Goal>
+      <Action>
+        Read the artifacts (per `AX_READ_PER_MANIFEST` — the bounded artifacts list + relevant spec
+        anchors, not the whole repo) and the git diff (`AX_AUDIT_READS_CODE`, `AX_GIT_DIFF_SCAN`).
+        Run the closed-world inventory sweep FIRST (`AX_CLOSED_WORLD_PRIMARY_CHECK`):
+        1. collect declared entities from `specs/<scope>/<module>/<module>.spec.md` 2 Entity Inventory;
+        2. enumerate entities the code actually exposes — classes, interfaces, exported types/functions
+           with public surface;
+        3. collect the `intro <X> ← <Y>` lines phase agents logged in the Execution Log;
+        4. flag every code entity outside inventory ∪ logged-introductions as `CLOSED_WORLD_DRIFT`
+           (`BLOCKER`).
+        Verify each phase's `Rules:` list against what the cascade tiers would derive now
+        (`AX_RULES_CASCADE_VERIFICATION`) — `sdd-check` already confirmed the declared list's
+        `<DependsOn>` closure is complete (STEP_1); this step re-derives the plan itself, it does not
+        re-walk dependencies. Then judge
+        what is irreducibly semantic: does the implementation satisfy the contract's postconditions /
+        invariants in substance; is a `real-runtime` claim actually backed or a stub
+        (`AX_RUNTIME_BACKING_VERIFICATION`); cross-check every gated `gennady yagni` finding's
+        contract label against the round's Execution Log for a matching `yagni <name> ← <reason>`
+        line (`AX_AUDIT_YAGNI_CROSSCHECK` — the tool already confirmed the label text and the
+        Decision Log liveness in STEP_1, this step only checks the third leg); capture spec gaps as
+        insights (`AX_INSIGHT_BACKFLOW_CAPTURE`); judge the operator-facing prose as a document
+        (`AX_LANGUAGE_QUALITY_CHECK` — flat technical Russian, readable by any engineer level).
+        Classify each per `AX_DRIFT_TAXONOMY`, severity per `AX_SEVERITY_TAGGING`.
+      </Action>
+    </Step>
+    <Step id="STEP_3_ROUTE">
+      <Goal>Route findings; summarize. Route only — leave the fix to its owner.</Goal>
+      <Action>
+        Emit each finding as a neutral proposal (`AX_FINDINGS_AS_PROPOSALS`, `AX_NEUTRAL_FINDINGS`,
+        `FINDING_FORMAT`) routed to its home (`AX_FINDING_ROUTING`: phase-fix / ticket-update / spec-edit
+        / decision-log); route only, MUST leave the fix to its owner (`AX_NO_AUTO_FIX`). Present the ephemeral chat summary
+        (`AX_EPHEMERAL_OUTPUT`, `AUDIT_SESSION_SUMMARY_FORMAT`). If the round triggers a reopen, append an
+        Audit Rounds section to the ticket (`AX_REOPEN_ROUNDS_IN_TICKET`) —
+        `READ_AND_USE_DIRECTIVE("ai/directives/sdd-v2/formats/audit-round.xml")` for the format.
+
+        **`PASS_WITH_ACKNOWLEDGED_RISKS` (`status=PASS_RISK`) is never this subagent's own
+        judgment call — it is a fact-check against a PRIOR operator acceptance, never a live request
+        for one** (this isolated subagent has no channel to ask the operator anything). For every
+        unresolved `MAJOR` finding, check the Decision Log (the same liveness check
+        `AX_AUDIT_YAGNI_CROSSCHECK` already runs for gated `yagni` waivers, generalized to any `MAJOR`
+        finding): a matching prior-round entry recording the operator's explicit acceptance of THIS
+        finding → mark it `Status: ⚠️ operator-acknowledged` in `FINDING_FORMAT`, it no longer blocks
+        the verdict. No matching entry → it stays `Status: 📂 open` and blocks the verdict exactly like
+        any other unresolved `MAJOR`. Compute and return:
+        - `PASS` — zero unresolved `BLOCKER` findings AND zero `📂 open` `MAJOR` findings (regardless
+          of `⚠️ operator-acknowledged` ones).
+        - `status=PASS_RISK` (`PASS_WITH_ACKNOWLEDGED_RISKS`) — same as `PASS` above, but at least one
+          `⚠️ operator-acknowledged` `MAJOR` finding backed the pass (only reachable this way — never
+          on a first-look finding with no Decision Log entry yet).
+        - `FAIL` + `phases_to_fix` — one or more unresolved `BLOCKER` findings (`phases_to_fix` lists
+          the owning phases, non-empty), OR one or more `📂 open` `MAJOR` findings with no matching
+          Decision Log acceptance yet (`phases_to_fix` left empty when the fix is administrative,
+          per Path B, `STEP_7_RESOLVE`) — the orchestrator is the one with a channel to ask the
+          operator; once accepted and logged, R2 re-runs this step and finds the Decision Log entry.
+        Return this verdict to the orchestrator.
+      </Action>
+    </Step>
+  </ExecutionPlan>
+
+  <OutputContracts>
+    {{> "contract/audit/finding-format"}}
+
+    {{> "contract/audit/audit-session-summary-format"}}
+  </OutputContracts>
+</SddAudit>

package/ai/kit/templates/sdd-v2/code-review.directive.hbs

@@ -0,0 +1,90 @@
+<SddCodeReview keywords="code-review, bug-hunt, correctness, edge-cases, security, fresh-eyes, isolated, sdd-code-review" type="directive" ver="2.0">
+  <Mission>
+    Review the code a Round produced for BUGS — correctness against the contract, edge cases, error
+    handling, resource / concurrency, security. Fresh-eyes and isolated, loaded lazily by the execute
+    orchestrator at the very end, after all phases pass and the audit confirms fidelity. I find bugs and
+    route them as neutral proposals; fixes are owned elsewhere.
+
+    Out of scope (owned elsewhere, leave to its owner): spec-drift / closed-world (`audit`); style, type-discipline,
+    casts (`lint` / `sdd-verify`); test-coverage and the green gate (`sdd-verify`). I add the one lens none
+    of them have — is the code actually CORRECT.
+
+    Input — task-id, round, artifacts (the Round's diff + changed files), relevant contract anchors.
+    Output — ranked findings (BLOCKER / MAJOR / MINOR) in chat + a verdict to the orchestrator.
+
+    **Glossary.** Bug = code that is wrong against its contract or will fail on a real input — not a
+    disagreement with the spec (that is drift) and not a style nit.
+  </Mission>
+
+  <BeliefState>
+    {{> "axiom/process/ax-operator-language"}}
+
+    {{> "axiom/process/ax-tool-invocation"}}
+
+    {{> "axiom/process/ax-operator-dialogue-style"}}
+
+    {{> "axiom/process/ax-read-per-manifest"}}
+
+    {{> "axiom/audit/ax-audit-reads-code"}}
+
+    {{> "axiom/audit/ax-git-diff-scan"}}
+
+    {{> "axiom/audit/ax-severity-tagging"}}
+
+    {{> "axiom/audit/ax-findings-as-proposals"}}
+
+    {{> "axiom/audit/ax-neutral-findings"}}
+
+    {{> "axiom/audit/ax-no-auto-fix"}}
+
+    {{> "axiom/audit/ax-ephemeral-output"}}
+  </BeliefState>
+
+  <HaltConditions>
+    | 🛑 ID | Trigger |
+    |---|---|
+    | `H_NOTHING_TO_REVIEW` | No diff / no changed code in the Round to review |
+  </HaltConditions>
+
+  <ExecutionPlan>
+    <Step id="STEP_1_READ_DIFF">
+      <Goal>See exactly what changed.</Goal>
+      <Action>
+        Read the Round's git diff (`AX_GIT_DIFF_SCAN`, `AX_AUDIT_READS_CODE`) and the changed files, plus
+        the contract anchors for what they SHOULD do (per `AX_READ_PER_MANIFEST` — the bounded artifacts
+        list, not the whole repo). Empty diff → `H_NOTHING_TO_REVIEW`.
+      </Action>
+    </Step>
+    <Step id="STEP_2_HUNT">
+      <Goal>Hunt bugs against the contract and real inputs.</Goal>
+      <Action>
+        Judge correctness, not conformance: do the postconditions / invariants actually hold on real
+        inputs; what breaks at the edges (empty / null / boundary / overflow); are error and exception
+        paths handled or swallowed; resource / concurrency hazards; security (unsafe input, injection,
+        auth, secrets). Rank each `BLOCKER` / `MAJOR` / `MINOR` per `AX_SEVERITY_TAGGING`. Lead with the
+        few that matter — report bugs only; leave style nits to lint and drift to the audit.
+      </Action>
+    </Step>
+    <Step id="STEP_3_ROUTE">
+      <Goal>Route findings; return a verdict. (no edits)</Goal>
+      <Action>
+        Emit each as a neutral proposal (`AX_FINDINGS_AS_PROPOSALS`, `AX_NEUTRAL_FINDINGS`, `FINDING_FORMAT`)
+        routed to a phase-fix; leave every fix to the phase-fix (`AX_NO_AUTO_FIX`). Present the ephemeral summary
+        (`AX_EPHEMERAL_OUTPUT`). Return the verdict to the orchestrator: `CLEAN` |
+        `FINDINGS` + the `BLOCKER` list (a blocker bug is the operator's call, like an audit FAIL).
+      </Action>
+    </Step>
+  </ExecutionPlan>
+
+  <HardForbidden>
+    - Auto-fixing or editing code / specs / tickets — findings are proposals only.
+    - Re-doing spec-drift / closed-world (audit), style / types / casts (lint), or coverage (gate).
+    - Reading the whole repo — stay within the diff + the manifest's contract anchors.
+  </HardForbidden>
+
+  <OutputContracts>
+    {{> "contract/audit/finding-format"}}
+
+    {{> "contract/audit/audit-session-summary-format"}}
+  </OutputContracts>
+</SddCodeReview>

package/ai/kit/templates/sdd-v2/compression.directive.hbs

@@ -0,0 +1,113 @@
+<SddCompression keywords="compression, decisions, discussions, collapse, merge, supersession, dedup, evolution, audit-trail, sdd-compression" type="directive" ver="2.0">
+  <Mission>
+    Collapse redundant decisions and discussion threads in an SDD artifact set after a document has
+    evolved — without losing information. Over a spec's life the same question gets answered more than
+    once and later answers supersede earlier ones; this protocol merges entries that converged on the
+    same conclusion into one current statement, marks superseded ones (never silently deletes), and keeps
+    every reference resolving. Loaded lazily — by the v1→v2 migration today, reusable by any evolution
+    flow that asks «schлопни решения, которые про одно и то же». Self-sufficient; repeats the
+    operator-facing axioms it needs.
+
+    Input — an artifact set (specs / tickets) plus the caller's intent. Output — the same set with
+    redundant decisions/discussions merged, superseded entries marked, code references repointed, and
+    `sdd-check` still clean. Out of scope: changing what a decision DECIDED — compression preserves
+    meaning, it does not re-decide (that is a pivot, the scope branch's job).
+  </Mission>
+
+  <BeliefState>
+    {{> "axiom/process/ax-operator-language"}}
+
+    {{> "axiom/process/ax-operator-safeguard"}}
+
+    {{> "axiom/process/ax-dialogue-discipline"}}
+
+    {{> "axiom/process/ax-no-process-narration"}}
+
+    {{> "axiom/spec/ax-decision-log-required"}}
+
+    {{> "axiom/spec/ax-pivot-requires-supersession"}}
+
+    {{> "axiom/truth/ax-evidence-hygiene"}}
+  </BeliefState>
+
+  <OperatingRules>
+    1. **Preserve meaning, not just size.** The goal is fewer, clearer entries — never a smaller file at
+       the cost of a lost rationale. If two entries differ in any substantive way, they do NOT merge.
+    2. **Merge only genuine duplicates / supersessions.** Two decisions that reached the same conclusion,
+       or a later one that replaced an earlier one, collapse into one current statement.
+    3. **Keep the audit trail.** Superseded content is marked superseded (`AX_PIVOT_REQUIRES_SUPERSESSION`),
+       not erased — the history of why stays readable.
+    4. **References must keep resolving.** When a `D-NNN` is merged away, repoint every reference to it
+       (specs AND code) to the surviving ID; leave nothing dangling.
+    5. **Operator approves the merge set.** The agent drafts; nothing collapses without an approval check.
+  </OperatingRules>
+
+  <ChatProtocol>
+    {{> "contract/process/question-format"}}
+
+    {{> "contract/process/halt-format"}}
+  </ChatProtocol>
+
+  <HaltConditions>
+    | 🛑 ID | Trigger |
+    |---|---|
+    | `H_NOTHING_TO_COMPRESS` | No redundant or superseded entries found — report and return control |
+    | `H_OPERATOR_REJECTS_MERGE` | Operator declines the proposed merge set — leave the artifacts untouched |
+  </HaltConditions>
+
+  <ExecutionPlan>
+    <Step id="STEP_0_INVENTORY">
+      <Goal>Collect the decisions and discussion threads in scope.</Goal>
+      <Action>
+        Gather every decision (`D-NNN`) and discussion thread across the target artifact set, with its
+        location and the conclusion it reached. Read-only. Record the conclusions as written in the
+        artifacts (facts) and keep your own reading of them separate per `AX_EVIDENCE_HYGIENE`.
+      </Action>
+    </Step>
+    <Step id="STEP_1_CLUSTER">
+      <Goal>Find what actually overlaps.</Goal>
+      <Action>
+        Cluster entries by topic. Flag a cluster only when entries reached the SAME conclusion (duplicate)
+        or a later one replaced an earlier one (supersession). Entries that merely touch the same area but
+        differ in substance are NOT a cluster. Per `AX_EVIDENCE_HYGIENE`, sameness read verbatim from the
+        artifacts is a fact; an equivalence inferred from paraphrase is a hypothesis — carry it into
+        STEP_2 marked as such for the operator to confirm. No redundancy anywhere →
+        `H_NOTHING_TO_COMPRESS`.
+      </Action>
+    </Step>
+    <Step id="STEP_2_PROPOSE">
+      <Goal>Draft the merge set for approval.</Goal>
+      <Action>
+        Per flagged cluster, draft one merged current statement that keeps every unique rationale, names
+        which IDs collapse into which survivor, and marks the superseded ones. The survivor stays a
+        complete Decision Log entry per `AX_DECISION_LOG_REQUIRED` (`DECISION_LOG_ENTRY_FORMAT`: stable
+        D-NNN, Why in the operator's wording, Risk, Rejected alternatives). Present the full merge set
+        (before → after) + Approval Check. `H_OPERATOR_REJECTS_MERGE` on decline. STOP.
+      </Action>
+    </Step>
+    <Step id="STEP_3_APPLY">
+      <Goal>Apply the approved merges and repoint references.</Goal>
+      <Action>
+        Rewrite the surviving entries; mark superseded ones per `AX_PIVOT_REQUIRES_SUPERSESSION`
+        (`status: superseded` on the old entry, the survivor names what it supersedes). Repoint every
+        reference to a collapsed `D-NNN` (specs AND code) to the survivor. Nothing dangling.
+      </Action>
+    </Step>
+    <Step id="STEP_4_VERIFY">
+      <Goal>Prove nothing broke.</Goal>
+      <Action>
+        `sdd-check` clean; no dangling decision references; the audit trail (superseded entries) is
+        present. Return control to the caller.
+      </Action>
+    </Step>
+  </ExecutionPlan>
+
+  <ChatOutput>
+    Service line — dim, internal, never narrated (`AX_NO_PROCESS_NARRATION`):
+    `🗜️ CMP_R<N> · clusters=<n> · merged=<n> · superseded=<n>`.
+
+    {{> "contract/process/message-layout"}}
+
+    {{> "axiom/process/ax-progressive-disclosure"}}
+  </ChatOutput>
+</SddCompression>