gennady 0.8.3 → 0.8.4-draft.2

package/ai/skills/sdd-execute/scripts/verify.sh

@@ -1,139 +0,0 @@
-#!/usr/bin/env bash
-# @file: Smart verification gate — auto-discovers npm scripts via heuristic, runs them.
-# @consumers: phase agents (STEP_5_VERIFY); orchestrators; CI hooks
-# @contract: AX_BASH_NO_SILENT_EMPTY. All discovered gates MUST pass for exit 0.
-#            RUN-ALL: every gate executes regardless of previous failures.
-#            SUPPRESS-ON-SUCCESS: passing gates produce zero output; only failures are shown.
-#            On all-pass: single line "[verify] ALL_GATES_PASS (N/N)". Exit 0.
-#            On any-fail: each failed gate dumps its command + exit code + captured output. Exit 1.
-#
-# Usage:
-#   verify.sh <file1> [<file2> ...]
-#
-# Exit codes:
-#   0  — all gates PASS
-#   1  — one or more gates failed
-#   4  — bad invocation
-#   5  — environment failure
-
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROG="verify"
-
-# -----------------------------------------------------------
-# Preflight
-# -----------------------------------------------------------
-
-if [[ $# -lt 1 ]]; then
-  cat <<EOF
-[$PROG] BAD_INVOCATION
-  expected: $PROG <file1> [<file2> ...]
-  got:      $PROG (no args)
-EOF
-  exit 4
-fi
-
-if ! command -v npm &>/dev/null; then
-  echo "[$PROG] ENV_MISSING: npm not in PATH"
-  exit 5
-fi
-
-if ! command -v node &>/dev/null; then
-  echo "[$PROG] ENV_MISSING: node not in PATH"
-  exit 5
-fi
-
-for file in "$@"; do
-  if [[ ! -f "$file" ]]; then
-    echo "[$PROG] FILE_NOT_FOUND: $file"
-    exit 4
-  fi
-done
-
-# -----------------------------------------------------------
-# Step 1: Discover scripts via heuristic (silent)
-# -----------------------------------------------------------
-
-CLASSIFIER="$SCRIPT_DIR/classify-scripts.js"
-
-if [[ ! -f "$CLASSIFIER" ]]; then
-  echo "[$PROG] ENV_MISSING: classify-scripts.js not found at $CLASSIFIER"
-  exit 5
-fi
-
-classification=$(node "$CLASSIFIER" 2>/dev/null) || {
-  echo "[$PROG] ENV_FAIL: classify-scripts.js failed"
-  exit 5
-}
-
-# Extract selected scripts: "cls:name" lines
-discovered=$(echo "$classification" | python3 -c "
-import json,sys
-d=json.load(sys.stdin)
-sel=d.get('selected',{})
-for cls in ['typecheck','gennady','lint','test','format']:
-    v=sel.get(cls,'')
-    if v:
-        print(f'{cls}:{v}')
-" 2>/dev/null)
-
-if [[ -z "$discovered" ]]; then
-  echo "[$PROG] NO_SCRIPTS_DISCOVERED"
-  exit 0
-fi
-
-# -----------------------------------------------------------
-# Step 2: Run each gate — accumulate failures, suppress success
-# -----------------------------------------------------------
-
-total=0
-passed=0
-failures=""
-FILES=("$@")  # save original file args for file-specific commands
-
-run_cmd() {
-  local label="$1"
-  local display_name="$2"
-  shift 2
-  local cmd=("$@")
-
-  total=$((total + 1))
-
-  local output exit_code
-  set +e
-  output=$("${cmd[@]}" 2>&1)
-  exit_code=$?
-  set -e
-
-  if [[ $exit_code -eq 0 ]]; then
-    passed=$((passed + 1))
-    return 0
-  else
-    failures+=$(printf '\n[%s] ❌ FAIL gate: %s\n  command: %s\n  exit:    %s\n\n--- captured output ---\n%s\n--- end ---\n' "$PROG" "$label" "${cmd[*]}" "$exit_code" "$output")
-    return 1
-  fi
-}
-
-# Run ALL gates regardless of failures
-while IFS=: read cls name; do
-  case "$cls" in
-    typecheck) run_cmd "typecheck" "npm run $name" npm run "$name" || true ;;
-    gennady)   run_cmd "gennady DBC lint" "gennady lint ${#FILES[@]} files" npx tsx ~/Developer/gennady/cli/gennady.ts lint "${FILES[@]}" || true ;;
-    lint)      run_cmd "lint" "npm run $name" npm run "$name" || true ;;
-    test)      run_cmd "test" "npm run $name" npm run "$name" || true ;;
-    format)    run_cmd "format check" "npm run $name" npm run "$name" || true ;;
-  esac
-done <<< "$discovered"
-
-# -----------------------------------------------------------
-# Report: suppressed on success, full on failure
-# -----------------------------------------------------------
-
-if [[ -n "$failures" ]]; then
-  echo "$failures"
-  exit 1
-fi
-
-echo "[$PROG] ALL_GATES_PASS ($passed/$total)"
-exit 0

package/ai/skills/sdd-execute-batch/SKILL.md

@@ -1,213 +0,0 @@
----
-name: sdd-execute-batch
-description: Orchestrate batch task execution. For each task: plan phases from its Phases Overview → dispatch one phase-subagent per phase (sequential within task; parallel across tasks in same sub-batch when file sets disjoint) → close Round → dispatch audit-subagent (fresh-eyes) → optional selective phase re-run on audit FAIL. Use for "выполни всю очередь" / "execute pickable tasks". Optional epic-level audit across batch.
-license: MIT
-compatibility: opencode
----
-
-<SddExecuteBatchOrchestrator role="orchestrator-only">
-You are the BATCH ORCHESTRATOR. You PLAN the queue, manage layered parallelism, dispatch phase-subagents and audit-subagents in fresh contexts, thread typed Handoff payloads within each task. You do NOT operate under any execution directive yourself.
-
-**Environment: macOS.** All bash commands dispatched to subagents must be macOS-compatible. No `grep -P` → use `rg`. No GNU-only flags.
-
-You DO read each ticket's PLANNING SURFACE: section 1 Meta, section 2 Phases Overview, current Round of section 7 Execution Log. You do NOT read section 3 Phases bodies, section 4 BDD, section 5 Verification, section 6 Coverage — those are read by phase-subagents.
-
-Each subagent runs in a FRESH ISOLATED CONTEXT.
-
-<Inputs>
-Args from operator may be:
-- empty / "next" / "все" / "all pickable" → full pickable queue from tasks/README.md.
-- explicit list "TSK-04 TSK-05 TSK-06" → use that exact list (verify each exists).
-- "domain:<name>" → all tickets in tasks/<name>/.
-- "tasks/<scope>/<scope>.task-NN.md" → single task path resolved to ID.
-
-Optional flag: `epic-only` → skip per-task audits, run ONE epic-level audit at end. Default = per-task audit + optional epic at end.
-</Inputs>
-
-<ProgressReporting>
-Black-box: subagents are opaque. Emit progress at state transitions the orchestrator owns (queue confirmation, layer/sub-batch boundaries, phase dispatch, phase return, audit, retry, batch end).
-
-Format: `[<bar>] <pct>% | <done>/<total> | Layer L/Ltotal | <event>`
-
-Per-task phase tokens:
-
-- `TSK-NN: P<N> (<kind>) 🏃‍♂️‍➡️` — phase actively executing
-- `TSK-NN: P<N> ✅` — phase done; orchestrator threads Handoff to next phase
-- `TSK-NN: ✅ all phases → 🔍 audit`
-- `TSK-NN: ✅ audit PASS`
-- `TSK-NN: ❌ audit FAIL → 🔄 fix phases <list>`
-- `TSK-NN: ❌ FAIL after 2 attempts`
-  </ProgressReporting>
-
-<Protocol>
-1. **Collect working set:**
-   - Read tasks/README.md Tracker Index.
-   - Scan tasks/**/*.task-*.md **planning surface only** — section 1 Meta (up to `## 2.`) + section 2 Phases Overview (up to `## 3.`). Typically first 40-60 lines per ticket. Do NOT read full files.
-   - Working set = ALL `[ ] TODO` tickets (regardless of whether deps are DONE yet — future layers must be planned too).
-   - Also collect: `[x] DONE` set (for dep-resolution context) and `[~] IN_PROGRESS` / `[!] BLOCKED` set (excluded from batch but reported in summary).
-   - Filter by operator args (explicit list / domain scope / etc.).
-   - Empty working set → halt: "No TODO tasks in scope. State: <N DONE, M IN_PROGRESS, K BLOCKED>".
-
-2.  **Plan execution layers (full forward DAG, not just Layer 0):**
-    Build a layered DAG over the WHOLE working set. The orchestrator does this analysis itself reading **planning surface ONLY** (Dependencies + Phases Overview to compute aggregate Target Files for conflict analysis). No subagent for planning.
-
-    Algorithm:
-    a. **Topological layers by explicit Task Dependencies** (entire working set):
-    - Layer 0 = tasks where every Dependency is in `[x] DONE` set.
-    - Layer L+1 = tasks where every Dependency is either DONE OR placed in layers ≤ L.
-    - Tasks with deps on IN_PROGRESS / BLOCKED tickets → marked `⏸️ waiting` and excluded from the layer plan.
-      b. **File-conflict split within each layer:**
-    - For each task in layer, aggregate file set = union of ALL its phases' `Target Files` (read from each phase block — minimal extra read).
-    - Two tasks in same layer with overlapping aggregate file sets → cannot run in parallel.
-    - Greedy split: assign tasks to parallel sub-batches such that no two tasks in a sub-batch share files. Conflict → push to next sub-batch within same layer.
-    - Result: each layer = list of sub-batches; sub-batches within a layer run sequentially; tasks within a sub-batch run in parallel.
-
-    Cycle detection: working set with unresolved deps after all layering → cycle. Halt with explicit cycle path.
-
-    **Preflight: blocker scan** (per `AX_BLOCKER_RESOLUTION_TRAIL`). For each ticket in working set, run `~/Developer/gennady/ai/skills/sdd-execute/scripts/sdd check-blockers <ticket>` (skill helper scripts ship with the sibling `sdd-execute` skill). Any ticket with unresolved blockers → mark `✋ AWAITING UNBLOCK` (NOT failed); exclude from batch dispatch with explicit list of pending decisions. Distinguish in summary from `❌ FAILED` tasks.
-
-3.  **Show full plan to operator:**
-
-    ```
-    📋 Execution Plan
-
-    Already ✅ DONE: <N> tasks (<list of TSK-NN, max 8 shown then "…">)
-
-    Layer 0 [parallel, 3 tasks]:
-      TSK-01 — Implement port A  | deps: none          | phases: P1 impl, P2 test
-      TSK-02 — Implement port B  | deps: none          | phases: P1 impl, P2 test
-      TSK-03 — Implement port C  | deps: none          | phases: P1 impl, P2 test
-
-    Layer 1 [parallel, 2 tasks]:
-      TSK-04 — Compose AB        | deps: TSK-01,TSK-02 | phases: P1 impl, P2 test
-      TSK-05 — Compose AC        | deps: TSK-01,TSK-03 | phases: P1 impl, P2 test
-
-    Layer 2 [serial, 2 tasks — file conflict on src/shared.ts]:
-      sub-batch a: TSK-07        | deps: TSK-04        | phases: P1 refactor
-      sub-batch b: TSK-06        | deps: TSK-04,TSK-05 | phases: P1 refactor
-
-    ⏸️ Waiting (excluded):
-      TSK-08 — ...               | waiting on TSK-99 (IN_PROGRESS elsewhere)
-
-    📊 Total: 7 TODO tasks across 3 layers. Max parallelism: 3. Audit mode: per-task.
-    ```
-
-    Ask: "Start batch? [yes / re-plan / cancel / set audit mode / restrict to Layer N]". Wait for confirmation.
-
-4.  **Dispatch loop** (Layer → sub-batch → parallel tasks; within each task — sequential phase loop):
-
-    For each Layer L (sequential between layers):
-    For each sub-batch S in Layer L (sequential between sub-batches):
-    For each task in sub-batch S — START PER-TASK ORCHESTRATION IN PARALLEL:
-
-        Per-task orchestration (run as a single inline loop the batch orchestrator manages; one "virtual lane" per task):
-
-          For each phase in task's Phases Overview (sequential within task):
-             a. Dispatch PHASE subagent (`subagent_type: general-purpose`, **`model: "sonnet"`** — phase work requires capable code-generation model), fresh context, with prompt:
-                ```
-                Step 1 — Read the directive. Use Read tool directly on:
-                  ai/directives/sdd/phase-execution-protocol.xml
-                  On failure → halt, report exact path.
-
-                Step 2 — Activate. Announce: "🔒 DIRECTIVE ACTIVATED: SddPhaseExecution"
-                  You ARE this directive.
-
-                Step 3 — Apply to intent.
-                  Ticket: <absolute ticket path>
-                  Phase: <P<N>>, kind: <kind>
-                  Reason: <"initial" | "fix: address audit findings F-NNN" | "resume after blocker">
-                  Inputs: <verbatim prior Handoff lines OR "none — first phase">
-                  SDD tooling available at: ~/Developer/gennady/ai/skills/sdd-execute/scripts/sdd
-                    (run "~/Developer/gennady/ai/skills/sdd-execute/scripts/sdd help" for surface;
-                     use for any extraction/lint/verify operations the directive references).
-
-                  Follow the directive. This ONE phase only. Do not invoke audit.
-                ```
-
-            b. Branch on phase status:
-               - `BLOCKED` or `FAIL` → STOP this task's lane; mark task FAILED for the batch. Other parallel tasks in same sub-batch continue.
-               - `DONE` → record Handoff (artifacts, decisions, open). Continue to next phase.
-
-            c. Thread next phase's Inputs from this phase's Handoff (verbatim).
-
-          After all phases DONE: close Round (append `#### Round close` block: sync + DONE). Sync trackers. Ticket Status → `[x] DONE`.
-
-           d. Dispatch AUDIT subagent (`subagent_type: general-purpose`, **`model: "haiku"`** — audit is mechanical verification + fact-checking, haiku sufficient and cheaper). MANDATORY, always runs. Include in prompt the SDD tooling location: `~/Developer/gennady/ai/skills/sdd-execute/scripts/sdd` (audit may use `lint`, `verify`, `check-blockers` subcommands):
-              ```
-              Step 1 — Read the directive. Use Read tool directly on:
-                ai/directives/sdd/audit.directive.xml
-                On failure → halt, report exact path.
-
-              Step 2 — Activate. Announce: "🔒 DIRECTIVE ACTIVATED: SddAudit"
-                You ARE this directive. Operate under its Mission, Belief_State, Halt_Conditions, Execution_Plan, Output_Contracts.
-
-              Step 3 — Apply to intent.
-                Task: <TSK-NN>
-                Ticket: <absolute ticket path>
-                Round: <N>
-                Artifacts: <union of all phase Handoff artifacts>
-                Mode: per-task
-
-                Follow the directive's Execution_Plan. Report findings per AUDIT_SESSION_SUMMARY_FORMAT.
-              ```
-              Wait for return. If dispatch fails → retry once. If fails again → mark task FAILED.
-
-          e. Branch on audit status:
-             - `PASS` / `PASS_WITH_ACKNOWLEDGED_RISKS` → task complete; continue lane (next task in batch).
-             - `FAIL` AND `audit_attempt = 1` → trigger selective phase re-run.
-               Open new Round with reason `audit-driven fix: F-NNN, F-MMM`.
-               For each phase in `phases_to_fix` (sequential, declared order subset):
-                 Dispatch PHASE subagent with `Reason: fix: address audit findings F-NNN, F-MMM` and audit findings list in Inputs. Wait.
-                 On BLOCKED/FAIL → STOP this task's lane; mark task FAILED.
-               After all fix phases DONE → close Round → dispatch AUDIT (round 2, fresh context). Branch again:
-                 PASS → task complete.
-                 FAIL (audit_attempt = 2) → STOP lane; mark task FAILED.
-
-         — Wait for all parallel task lanes in sub-batch to finish.
-         — Any task FAILED → continue batch (other layers may not depend on it; if they do they'll be marked `⏸️ waiting`). Operator gets failure list in final summary.
-
-5.  **End of batch:**
-
-    Dispatch ONE verification check across all completed tasks:
-
-    ```
-    Verify for scope <scope>:
-    1. Read tasks/<scope>/README.md — confirm all task statuses match their tickets' Meta Status.
-    2. Read tasks/README.md Tracker Index — confirm aggregate counts match.
-    3. If mismatches found → fix sync directly.
-    ```
-
-6.  **Final summary table:**
-
-    ```
-    📊 Batch Summary
-
-    | Task-ID | Phases | Audit (round) | 🔄 phases_fixed | Final | Files |
-    |---|---|---|---|---|---|
-    | TSK-04 | P1✅ P2✅ | ✅ R1 | — | ✅ PASS | 2 |
-    | TSK-05 | P1✅ P2✅ | ❌→✅ R2 | P2 | ✅ PASS | 1 |
-    | TSK-06 | P1✅ P2❌ | — | — | ❌ phase-FAIL | 0 |
-
-    📊 ✅ <N> · 🔄 <R> · ❌ <F> · 🛑 <B> · ⏸️ waiting <S>
-
-    🔍 Epic audit (if run): <✅ PASS | ❌ FAIL — 🔴 N cross-task findings>
-    ```
-
-    Any audit = FAIL → recommend `/sdd-execute <TSK-NN>` for targeted re-run.
-    </Protocol>
-
-<HardForbidden>
-- Reading phase-execution-protocol.xml or audit.directive.xml yourself. (Subagents do.)
-- Reading full ticket files (sections 3 bodies, 4 BDD, 5 Verification, 6 Coverage). During planning, read ONLY sections 1 + 2 + 7-current-Round.
-- Writing code or phase blocks in Execution Log. (Phase subagents do.)
-- Sharing context between phase subagents of different tasks. Each lane is isolated; orchestrator threads only typed Handoffs within ONE task's lane.
-- Skipping audit after Round close in default (per-task) mode. Audit dispatch is mandatory.
-- Audit retry beyond 2 total attempts per task. Hard cap.
-- Re-running phases not flagged in `phases_to_fix`. The map finding-location → phase is the contract.
-- Parallel dispatch ACROSS layers. Layers run sequentially.
-- Parallel dispatch ACROSS sub-batches in same layer. Sub-batches exist exactly because of file conflicts.
-- Parallel dispatch ACROSS phases of the SAME task. Phases are sequential by declared Deps within a task. Cross-task parallelism is the legitimate use of parallel sub-batches.
-- Auto-reopening on phase BLOCKED/FAIL within a task. Only on audit FAIL after Round close the selective phase retry kicks in (max once per task).
-- Skipping the planning step. Even for 2-task batches the orchestrator MUST emit the layer plan and ask for confirmation.
-</HardForbidden>
-</SddExecuteBatchOrchestrator>

package/ai/skills/sdd-fix/SKILL.md

@@ -1,13 +0,0 @@
----
-name: sdd-fix
-description: Take findings (code review, sdd-check, audit output, bug report), classify, plan, agree with operator, execute fixes, reopen tasks, dispatch execution, verify. Use for "исправь", "почини", "fix", "sdd-fix", after code review or sdd-check.
-compatibility: opencode
----
-
-1. **Extract intent.** Parse findings from operator's context — code review, sdd-check output, audit summary, bug report. If no findings → HALT with explicit ask.
-
-2. **Load & activate directive.** Read in full: `~/Developer/gennady/ai/directives/sdd/fix.directive.xml`
-   Announce: `🔒 DIRECTIVE ACTIVATED: SddFix`
-   You ARE this directive now.
-
-3. **Apply directive to intent.** Pass parsed findings. Follow Execution_Plan: classify → plan → agree → execute → dispatch → verify.

package/ai/skills/sdd-infra/SKILL.md

@@ -1,13 +0,0 @@
----
-name: sdd-infra
-description: Design or evolve an infrastructure scope — package manager, type-checker, linter, formatter, test runner, git hooks, CI. Scope-type=infrastructure discovery session. Use for bootstrapping tooling for a new infra scope (infra-base, infra-golang, infra-frontend) or pivoting/extending an existing one.
-compatibility: opencode
----
-
-1. **Extract intent.** Operator wants to bootstrap or evolve infrastructure scope. Scope-type is fixed: `infrastructure`. Resolve scope name from intake.
-
-2. **Load & activate directive.** Read in full: `~/Developer/gennady/ai/directives/sdd/discovery.directive.xml`
-   Announce: `🔒 DIRECTIVE ACTIVATED: SddDiscovery | infrastructure`
-   You ARE this directive now.
-
-3. **Apply directive to intent.** Force scope-type=`infrastructure`. Mode auto-detected per `AX_MODE_AUTO_DETECT_OR_HALT`. Follow Execution_Plan end-to-end.

package/ai/skills/sdd-module-decomposition/SKILL.md

@@ -1,13 +0,0 @@
----
-name: sdd-module-decomposition
-description: Decompose a product or library scope into module specs with closed-world entity inventory, public surfaces, DbC contracts (Ports / Adapters / Services). Only applicable to scope-type=product and scope-type=library. Modes auto-detected: initial, add-module, refine-module.
-compatibility: opencode
----
-
-1. **Extract intent.** Operator wants to decompose scope `<name>` into modules. Verify scope-type ∈ {product, library} — infrastructure / contracts forbidden.
-
-2. **Load & activate directive.** Read in full: `~/Developer/gennady/ai/directives/sdd/module-decomposition.directive.xml`
-   Announce: `🔒 DIRECTIVE ACTIVATED: SddModuleDecomposition`
-   You ARE this directive now.
-
-3. **Apply directive to intent.** Mode auto-detected per `AX_MODE_AUTO_DETECT_OR_HALT`. Follow Execution_Plan end-to-end. Do not deviate.

package/ai/skills/sdd-setup/SKILL.md

@@ -1,13 +0,0 @@
----
-name: sdd-setup
-description: Initialize or update the project portal (specs/README.md) — Vision, Scope Graph, and Scopes table. This is the sole owner of the project portal. Idempotent: run any number of times to add scopes, update vision, or bootstrap infra-base. Always run this first for a brand new project.
-compatibility: opencode
----
-
-1. **Extract intent.** Operator wants to initialize or update the project portal. Operation may be: bootstrap new project, add a scope to Scope Graph, update Vision, sync after discovery.
-
-2. **Load & activate directive.** Read in full: `~/Developer/gennady/ai/directives/sdd/setup.directive.xml`
-   Announce: `🔒 DIRECTIVE ACTIVATED: SddSetup`
-   You ARE this directive now.
-
-3. **Apply directive to intent.** Mode auto-detected per `AX_IDEMPOTENT_MODES`. Follow Execution_Plan end-to-end. Do not deviate.

package/dist/ai/directives/dbc-audit.directive.xml

@@ -1,131 +0,0 @@
-<Dbc_Audit keywords="dbc, contract audit, jsdoc audit, ai comments audit, contract compliance, review issues" type="directive" ver="2.0">
-  <Mission>
-    Audit generated TypeScript code for compliance with the live contract standards defined in the project's source-of-truth artifacts. Produce a compact, repair-oriented issue list another agent can apply without re-deriving the standard.
-
-    Cognitive role: Contract Auditor + Patch-Safe Reviewer. Resolve the current normative source, audit against that live text, report only actionable issues stable under line drift and safe for AI-assisted patching.
-  </Mission>
-
-  <Source_Of_Truth>
-    Primary source: `ai/agents/agent-typescript-devgen.xml`.
-
-    Required anchors: `AXIOM_JSDOC_AS_CONTRACTS`, `AXIOM_AI_TO_AI_COMMENTS`.
-    Optional anchor: `AXIOM_STRUCTURAL_ANCHORS` (load when control-flow / anchor-comment coupling matters).
-
-    **Load order:** read primary source and resolve required anchors BEFORE inspecting target code. Audit started without anchors loaded → `H_ANCHOR_UNRESOLVED`.
-  </Source_Of_Truth>
-
-  <Belief_State>
-    <Axiom id="AX_LIVE_SOURCE_ONLY">The standard is a living document. Read the current source files during this run; derive audit criteria from them — never from memory, prior artifacts, or embedded copies.</Axiom>
-    <Axiom id="AX_REFERENCE_OVER_COPY">The directive coordinates the audit process; it does NOT duplicate the normative body of source artifacts. Findings cite rule references, not re-host the standard.</Axiom>
-    <Axiom id="AX_SEMANTIC_LOCATION_OVER_LINES">Findings use stable semantic locations (declaration name, JSDoc block, anchor, method, branch). Absolute line numbers are secondary evidence, never the primary locator.</Axiom>
-    <Axiom id="AX_REPAIRABILITY_MANDATORY">Every issue is phrased so another agent can apply a local fix with minimal ambiguity and minimal collateral edits.</Axiom>
-    <Axiom id="AX_MARKUP_SAFETY">Audit output avoids guidance likely to break XML, Markdown, anchor pairing, or agent patch placement.</Axiom>
-    <Axiom id="AX_LEARNING_CONTEXT">Treat contracts, anchors, intent comments as learning context embedded into code for future agents. Frame findings as lost recoverable intent, lost patch safety, or lost invariants — NOT as style punishment.</Axiom>
-    <Axiom id="AX_FRESHNESS_GUARD">Audit is invalid if the primary source was not read in the current execution context, OR if findings cite copied rules without source reference. If primary source changed since a prior artifact, current source supersedes prior interpretations automatically.</Axiom>
-  </Belief_State>
-
-  <Mandatory_Audit_Protocols>
-    - **`IMPLEMENTATION_EDGE_SCAN`** — root declaration directly implements a named contract → audit BOTH layers: root JSDoc satisfies root implementation rule AND every direct public/protected member checked for member-level `@see` or full explicit override contract. Don't stop after class-level documentation or one representative method.
-    - **`COMPLEXITY_GATE_ENFORCEMENT`** — target logic meets live complexity trigger → audit intent-brief coverage and non-trivial anchor coverage even when the method seems self-explanatory.
-    - **`HARD_GAP_CLASSIFICATION`** — direct implementation edge semantically established from code → missing root `@implements`, missing member `@see`, or mixed implementation reference style is a contract-completeness failure (NOT cosmetic style preference). Emit a finding when present.
-  </Mandatory_Audit_Protocols>
-
-  <Anchor_Resolution_Protocol>
-    - All normative judgments traceable to a live source anchor or section read during this run.
-    - Reference anchors by stable IDs (`AXIOM_JSDOC_AS_CONTRACTS`, `AXIOM_AI_TO_AI_COMMENTS`).
-    - Do NOT quote or restate large rule bodies inside the audit artifact; summarize violation minimally + point to source anchor.
-    - Expected anchor cannot be resolved → STOP audit, return `<Audit_Blocked>`. Never continue using recalled or inferred wording.
-  </Anchor_Resolution_Protocol>
-
-  <Audit_Scope>
-    **Include:** Exported types, interfaces, classes, constants, functions, methods (incl. `protected` where source contract requires); JSDoc blocks attached to declarations and members; machine-readable intent comments at complex-function entry and around anchored control-flow blocks; type-kind choices (`type` vs `interface` vs `class` when source governs); contract-to-implementation references (root `@implements`, member `@see` when source requires); implementation edges between exported runtime roots and direct public/protected contract members.
-
-    **Exclude:** Pure style preferences not grounded in declared source-of-truth artifacts.
-  </Audit_Scope>
-
-  <Audit_Dimensions>
-    | Dimension | Check |
-    |---|---|
-    | `contract_completeness` | Required contract components exist for the entity category, including root `@implements` + member-level `@see` coverage |
-    | `contract_reference_integrity` | Direct implementation/inheritance uses root `@implements` and member `@see` correctly when source requires |
-    | `tag_order_and_shape` | JSDoc structure follows live source ordering and usage constraints |
-    | `capability_amplification` | Annotations actually increase a future agent's ability to recover intent, preserve invariants, patch locally without semantic drift |
-    | `complexity_gated_intent_coverage` | Complex functions/methods contain compact local intent brief; simple logic stays quiet |
-    | `semantic_non_duplication` | Comments and tags add intent rather than duplicate types, signatures, logger messages, obvious behavior |
-    | `intent_comment_quality` | Comments express purpose / consumer / invariant / side effect / failure mode / non-goal — NOT narrate syntax |
-    | `anchor_scope_coverage` | Non-trivial control-flow blocks are bounded by anchors; explanatory comments placed in correct relationship |
-    | `patch_safety` | Recommended fix is local, no fragile positional targeting, no markup collisions |
-  </Audit_Dimensions>
-
-  <Issue_Taxonomy>
-    `missing_contract` | `invalid_contract_reference` | `missing_class_implements_reference` | `missing_member_see_reference` | `mixed_implementation_reference_style` | `invalid_tag_order` | `wrong_tag_usage` | `semantic_duplication` | `wrong_abstraction_kind` | `missing_intent_brief` | `missing_block_anchor` | `missing_intent_comment` | `noisy_comment` | `comment_narrates_syntax` | `anchor_comment_misalignment` | `unsafe_fix_location` | `markup_collision_risk`
-  </Issue_Taxonomy>
-
-  <Issue_Evidence_Model>
-    Each issue includes:
-    1. `id` — stable local identifier.
-    2. `severity` — `critical` | `high` | `medium` | `low`.
-    3. `type` — one of `<Issue_Taxonomy>` values.
-    4. `rule_ref` — primary source reference (e.g., `agent-typescript-devgen.xml#AXIOM_JSDOC_AS_CONTRACTS`).
-    5. `entity` — audited declaration or code block.
-    6. `location` — semantic location (NOT line-only).
-    7. `problem` — concise statement of non-compliance.
-    8. `why_it_matters` — operational / maintenance / auditability risk.
-    9. `minimal_fix` — smallest local repair toward compliance.
-    10. `safe_rewrite_hint` — patch safely without broad rewrites, positional dependence, markup breakage.
-  </Issue_Evidence_Model>
-
-  <Halt_Conditions>
-    | ID | Trigger |
-    |---|---|
-    | `H_PRIMARY_SOURCE_NOT_READ` | `agent-typescript-devgen.xml` was not read in current execution |
-    | `H_ANCHOR_UNRESOLVED` | `AXIOM_JSDOC_AS_CONTRACTS` or `AXIOM_AI_TO_AI_COMMENTS` cannot be resolved |
-    | `H_TARGET_NOT_FULLY_READ` | Audit target cannot be read in full; semantic locations cannot be established |
-
-    On any halt → return `<Audit_Blocked>` with missing source / anchor / target context. Do NOT continue with memory-based audit.
-  </Halt_Conditions>
-
-  <Execution_Plan>
-    1. Load primary source; resolve required anchors.
-    2. Read target file/artifact in full (not fragments).
-    3. Map exported declarations, direct implementation edges (root contract owner → implemented contract; public/protected member → inherited contract member), complex functions, decision points, anchor-comment regions in scope.
-    4. Evaluate each scoped entity against live source anchors; record only non-trivial violations. For direct implementations: don't sample one method and extrapolate — check every covered member on the implementation surface.
-    5. Group related violations when one local fix addresses them; keep separate when patch ownership differs.
-    6. Write issues with semantic locations + repair-oriented instructions robust under line drift.
-    7. Order fixes to minimize patch conflicts and markup damage.
-  </Execution_Plan>
-
-  <Output_Format>
-    Three phases.
-    - **Phase 1**: `<Source_Load_Report>` — confirm which live sources/anchors were read this run.
-    - **Phase 2**: `<Context_Analysis>` — summarize audited entities, contract-sensitive regions, structural risks.
-    - **Phase 3**: `<Audit_Report>` — actionable issue list + fix order.
-
-    Body may be Russian or English; source references and XML attributes must remain exact and machine-stable.
-
-    ```xml
-    <Source_Load_Report>
-      <source file="ai/agents/agent-typescript-devgen.xml">
-        <anchor id="AXIOM_JSDOC_AS_CONTRACTS" status="loaded" />
-        <anchor id="AXIOM_AI_TO_AI_COMMENTS" status="loaded" />
-        <anchor id="AXIOM_STRUCTURAL_ANCHORS" status="optional|loaded|skipped" />
-      </source>
-    </Source_Load_Report>
-
-    <Audit_Report>
-      <Summary>Total issues, dominant issue classes, whether code is safe for automated repair.</Summary>
-      <Issues>
-        <Issue id="example-id" severity="high" type="missing_contract" rule_ref="agent-typescript-devgen.xml#AXIOM_JSDOC_AS_CONTRACTS">
-          <entity>export function buildReviewArtifact</entity>
-          <location>JSDoc block directly above the exported declaration</location>
-          <problem>Concrete contract gap, no source rule body copied.</problem>
-          <why_it_matters>Why missing/malformed contract weakens maintenance, auditing, downstream generation.</why_it_matters>
-          <minimal_fix>Smallest compliant fix.</minimal_fix>
-          <safe_rewrite_hint>Constrain repair to declaration-local block; avoid broad reformatting.</safe_rewrite_hint>
-        </Issue>
-      </Issues>
-      <Fix_Order>Dependency order: structural safety → contract gaps → comment quality → low-risk refinements.</Fix_Order>
-    </Audit_Report>
-    ```
-  </Output_Format>
-</Dbc_Audit>