gennady 0.7.0 → 0.8.0

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

@@ -0,0 +1,213 @@
+---
+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

@@ -0,0 +1,13 @@
+---
+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

@@ -0,0 +1,13 @@
+---
+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

@@ -0,0 +1,13 @@
+---
+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-scaffold/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: sdd-scaffold
+description: Decompose specs (root + domain + infra) into a DAG of compact task tickets ready for autonomous execution by sdd-execute orchestrator. Materializes Cascade Table, Tracker Index, BDD scenarios, Phases Overview + per-phase Rules. Use for first task generation from spec tree, or scaffolding tasks for a new/refined domain. Modes auto-detected: initial, extend-dag.
+compatibility: opencode
+---
+
+1. **Extract intent.** Operator wants to scaffold tasks for {scope | all scopes}. Mode: `initial` (no `tasks/` yet) or `extend-dag` (`tasks/` exists, adding to it).
+
+2. **Load & activate directive.** Read in full: `~/Developer/gennady/ai/directives/sdd/scaffold.directive.xml`
+   Announce: `🔒 DIRECTIVE ACTIVATED: SddScaffold`
+   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

@@ -0,0 +1,13 @@
+---
+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/coding/result-conventions.xml

@@ -1,6 +1,6 @@
-<ResultConventions keywords="result, error-handling, isErr, TessellError, unwrap, success, fail" type="coding-rule" ver="1.0">
+<ResultConventions keywords="result, error-handling, isErr, TessellError, must, success, fail" type="coding-rule" ver="1.2">
   <Mission>
-    Invariants for the Result pattern from @tessell/core/result. Four binary idioms (R1–R4) are enforced via ESLint custom rules (eslint-plugin-tessell-result); each maps to a forbidden idiom in AGENTS.md that survived code review and was caught retroactively. One architectural convention (AX_RESULT_PUBLIC_BOUNDARY) is code-review-only — not mechanically detectable.
+    Invariants for the Result pattern from @tessell/core/result. Seven conventions (R1–R7) are enforced via ESLint custom rules (eslint-plugin-tessell-result); each codifies an idiom from AGENTS.md that survived code review. The architectural convention AX_RESULT_PUBLIC_BOUNDARY is largely code-review-only — R7 enforces its mechanically-detectable subset. Canonical consumption idiom: `must` + try/catch.
   </Mission>
 
   <Belief_State>
@@ -17,10 +17,20 @@
     </Axiom>
 
     <Axiom id="AX_NO_RESULT_ISERR_SHORT_CIRCUIT">
-      `if (isErr(r)) return r` and `if (!isOk(r)) return r` are forbidden. Use `unwrap + try/catch` — that is the whole point of the convention.
+      `if (isErr(r)) return r` and `if (!isOk(r)) return r` are forbidden. Use `must` + try/catch — that is the whole point of the convention.
       No autofix: requires restructuring the surrounding function, not a one-line substitution.
     </Axiom>
 
+    <Axiom id="AX_NO_RESULT_OK_SHORT_CIRCUIT">
+      `if (!r.ok) return r` and `if (r.ok === false) return r` (property-access short-circuit form, the twin of AX_NO_RESULT_ISERR_SHORT_CIRCUIT) are forbidden. Use `must` + try/catch.
+      Detection: IfStatement whose test is `!r.ok` or `r.ok === false`, whose consequent is a bare `return r` (or a block with exactly one such return), and whose returned identifier matches the object of the `.ok` access.
+      No autofix: requires restructuring the surrounding function, not a one-line substitution.
+    </Axiom>
+
+    <Axiom id="AX_MUST_EXTRACTOR">
+      Extract a Result's value with `must`: `must(result)` returns the data or throws the contained error. It is synchronous and takes only a resolved Result — for a `Promise<Result>` write `must(await fn())`, so a forgotten await is a compile error. Combine with try/catch at the boundary.
+    </Axiom>
+
     <Axiom id="AX_NO_BARE_THROW_UNKNOWN">
       `throw catchBinding` without wrapping in `TessellError.cast` is forbidden when the binding is a CatchClause parameter (type unknown). Applies in wrapper/guard functions that rethrow, not only in catch blocks that return fail().
       Detection: scope analysis — ThrowStatement whose argument resolves to a CatchClause parameter, regardless of variable name (cause, err, e, error).
@@ -31,13 +41,18 @@
       Result is the transport form of error across the public / port boundary — not an internal control-flow primitive. Public surface (port interface methods, exported factory return types, closures returned from factories) MUST return `Result<T>`. Inside the same class:
       - protected/private async helpers with I/O → throw; the public caller wraps in try/catch and returns `fail(error)` (per AX_CATCH_LOG_RECOVER in typescript-rules).
       - pure helpers (predicates, classifiers) → honest return type (`Error | null`, scalar, enum literal); not Result.
-      - Result in protected is permitted only when the helper carries a typed `kind` the public call-site immediately unwraps — and even then, throw is usually cleaner because it avoids the `Result → unwrapSync → throw → catch → re-emit` double-packaging pattern.
+      - Result in protected is permitted only when the helper carries a typed `kind` the public call-site immediately extracts (via `must`) — and even then, throw is usually cleaner because it avoids the `Result → must → throw → catch → re-emit` double-packaging pattern.
 
       Rationale: mixing Result and null-pattern in helpers of one class produces structural noise (two error-channel styles in one surface) and double-packaging. The convention keeps Result as a boundary artifact, not an internal one.
 
       Not ESLint-enforced. The public/private boundary is not mechanically detectable: closures returned from factories (e.g. `defineDataStorageQuery → (storage, params) => Promise<Result<R>>`) are public-by-intent but private-by-syntax, and methods on factory-returned object literals (e.g. `defineDataOperation`) are not visible as class members. Enforced via code review and this directive.
     </Axiom>
 
+    <Axiom id="AX_GUARDED_RESULT_BOUNDARY">
+      A public Result-returning surface guards thrown errors. If a public class method or exported function returns `Result<T>` / `Promise<Result<T>>` and calls `must(...)`, that call must sit inside a try/catch whose `catch` returns `fail(...)` — otherwise the thrown error escapes the boundary instead of becoming `Err`.
+      Detection: explicit return-type annotation `Result`/`Promise<Result>` + a `must` call outside try (no autofix; optional suggestion). ESLint-enforceable subset of AX_RESULT_PUBLIC_BOUNDARY — factory-returned closures stay code-review (private-by-syntax).
+    </Axiom>
+
     <Axiom id="AX_CONFIGURABLE_NAMES">
       Every rule that matches function or type names accepts an options object with configurable identifiers: resultTypeName, isErrFn, isOkFn, successFn, failFn, castFn.
       Defaults match @tessell/core/result exports. On package rename — update config, not the rule.
@@ -47,9 +62,12 @@
   <Reward_Criteria>
     - R1 flags `Result<T, DataStorageError>`, autofixes to `Result<T>`. Does NOT flag `Result<T, E>` where E is a type parameter of the enclosing generic.
     - R2 flags `{ ok: true, data: x, error: null }`, autofixes to `success(x)`.
-    - R3 flags `if (isErr(r)) return r` with no autofix; error message cites `unwrap + try/catch`.
+    - R3 flags `if (isErr(r)) return r` with no autofix; error message cites `must` + try/catch.
     - R4 flags `throw e` inside any catch where e is the catch binding, regardless of variable name.
-    - R3 and R4 carry explanatory comment in eslint.config.ts (non-autofix path per eslint-setup AX_CUSTOM_PLUGINS_OBEY_META_POLICY).
-    - Each rule has Vitest tests: positive case, negative case, edge case (R1: type param exception; R4: non-catch-binding throw not flagged).
+    - R5 flags `if (!r.ok) return r` and `if (r.ok === false) return r` with no autofix; does NOT flag `if (!r.ok) doSomethingElse()`.
+    - R6 enforces `must` as the only Result extractor: autofixes to `must` where unambiguous, report-only otherwise; acts only on result-module identifiers, never foreign packages. Detection/autofix matrix: rule + TSK-58.
+    - R7 flags an unguarded `must(...)` (or a catch not returning `fail`) in a public class method / exported function annotated `Result`/`Promise<Result>`; no autofix (optional suggestion). Does NOT flag private/protected, inferred-return-type, or factory-returned closures.
+    - R3, R4, R5, R7 and the non-autofix path of R6 carry explanatory comment in eslint.config.ts (per eslint-setup AX_CUSTOM_PLUGINS_OBEY_META_POLICY).
+    - Each rule has Vitest tests: positive case, negative case, edge case (R1: type param exception; R4: non-catch-binding throw not flagged; R6: autofixable vs report-only forms + foreign-import not flagged; R7: factory-closure/private/inferred-type not flagged).
   </Reward_Criteria>
 </ResultConventions>

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

@@ -294,7 +294,7 @@
         1. TRACE_HEADER (STACK `ROOT__PRECONDITIONS_CHECK`).
         2. Inspect Execution Log: `[x] DONE` present? Verification commands executed and recorded?
         3. Not closed → `H_TICKET_NOT_DONE`. Module or scope spec missing → `H_NO_MODULE_SPEC`.
-        4. **Mechanical pre-pass.** (a) Lint: changed `.ts` files in this Round (per `AX_GIT_DIFF_SCAN`) → `npx tsx /Users/k.lebedev/Developer/gennady/cli/gennady.ts lint <files...>`; each issue → `RULES_COMPLIANCE_VIOLATION` tagged `mechanically-detected: <rule-id>`. No `.ts` / tool absent → skip silently / log warning. (b) Anchor balance: `~/.claude/skills/sdd-execute/scripts/sdd scan <project-root>`; each `anchor-mismatch:<opens>-open/<closes>-close` line in `[WARNINGS]` → `EXECUTION_LOG_INCOMPLETE` (`MAJOR`) tagged `anchor-unbalanced`, `loc=<file>:<opens>/<closes>`. Universal — name-agnostic, works on any markdown artifact. Per-ticket name coverage happens in STEP_2_5.
+        4. **Mechanical pre-pass.** (a) Lint: changed `.ts` files in this Round (per `AX_GIT_DIFF_SCAN`) → `npx tsx ~/Developer/gennady/cli/gennady.ts lint <files...>`; each issue → `RULES_COMPLIANCE_VIOLATION` tagged `mechanically-detected: <rule-id>`. No `.ts` / tool absent → skip silently / log warning. (b) Anchor balance: `~/.claude/skills/sdd-execute/scripts/sdd scan <project-root>`; each `anchor-mismatch:<opens>-open/<closes>-close` line in `[WARNINGS]` → `EXECUTION_LOG_INCOMPLETE` (`MAJOR`) tagged `anchor-unbalanced`, `loc=<file>:<opens>/<closes>`. Universal — name-agnostic, works on any markdown artifact. Per-ticket name coverage happens in STEP_2_5.
         5. Phase Progress + Approval Check. STOP otherwise → STEP_2.
       </Action>
     </Step>

package/dist/ai/directives/sdd/critic-protocol.xml

@@ -0,0 +1,78 @@
+<SddCriticProtocol keywords="critic, artifact-review, spec-review, task-review, bdd-audit, blind-spot, comprehension-gap, isolation" type="directive" ver="1.0">
+  <Directive_Context>
+    <Mission>
+      Read ONE artifact — spec or task — and emit a structured critique. ISOLATED context: you see ONLY this artifact and its parent spec (tasks only). READ and REPORT only. NEVER edit files. Find specification defects that threaten production: ambiguous boundaries, missing realistic error paths, unstated runtime assumptions, contradictions, incomplete BDD scenarios, misalignment with parent spec.
+    </Mission>
+  </Directive_Context>
+
+  <Belief_State>
+    <Axiom id="AX_READ_ONLY">Read artifact + parent spec. Write text output. NEVER edit files — orchestrator applies edits.</Axiom>
+    <Axiom id="AX_ISOLATION">Only artifact + parent spec. No other files. Confusion → underspecification.</Axiom>
+    <Axiom id="AX_COMPREHENSION_FIRST">Report understanding before problems. Misunderstanding signals ambiguity.</Axiom>
+
+    <Axiom id="AX_SPEC_DIMENSIONS">
+      Spec quality dimensions:
+      1. Boundary — explicit scope / out-of-scope statements.
+      2. Purpose — who uses this, for what. Use cases.
+      3. Entities — all named, public surfaces defined, relationships clear.
+      4. Contracts — Ports/Adapters/Services: pre/post conditions, invariants.
+      5. Dependencies — external deps named and versioned.
+      6. Failure modes — what breaks when dep unavailable, input invalid, happy path fails.
+      7. Non-goals — explicit exclusions.
+      8. Consistency — no internal contradictions.
+      9. Testability — claims verifiable, not vague ("should be fast").
+    </Axiom>
+
+    <Axiom id="AX_TASK_DIMENSIONS">
+      Task quality dimensions:
+      1. BDD — Happy path, edge cases (empty/max/boundary), error paths (network/file/timeout), negative cases. Concrete GIVEN/WHEN/THEN required.
+      2. Spec alignment — entity names match spec. Contracts covered by phases. Verification refs correct.
+      3. Phases — ordered correctly, deps explicit, no gaps (impl without test), Target Files non-overlapping.
+      4. Clarity — fresh agent can build from this alone. Inputs/outputs specified.
+      5. Completeness — all sections filled, no <TBD> or <YYYY-MM-DD>.
+    </Axiom>
+
+    <Axiom id="AX_SEVERITY">
+      CRITICAL — unusable, downstream agent produces wrong work.
+      MAJOR — gap requiring rework.
+      MINOR — improvement, vague wording.
+      INFO — observation.
+    </Axiom>
+
+    <Axiom id="AX_UNCERTAINTY_IS_SIGNAL">"I don't understand X" is valid output. Uncertainty = underspecification.</Axiom>
+
+    <Axiom id="AX_PRODUCTION_REALISM">
+      Test: would this gap cause user-visible failure or data loss within one month of deployment? Internal boundaries → type system is the contract, do not flag type-violation scenarios. External boundaries (API, I/O, user input, third-party) → input validation gaps are real.
+    </Axiom>
+  </Belief_State>
+
+  <Anti_Patterns>
+    <Pattern id="AP_EDIT">Editing files. Read + report only.</Pattern>
+    <Pattern id="AP_SURFACE">Reading headers only. Read full content.</Pattern>
+    <Pattern id="AP_NITPICK">Minor wording flagged as CRITICAL. Focus on what breaks downstream agent.</Pattern>
+    <Pattern id="AP_CERTAINTY">Declaring certainty without verification. "Not sure" > wrong answer.</Pattern>
+    <Pattern id="AP_FORMAT_BIAS">Assuming quality from formatting. Structure ≠ correctness.</Pattern>
+    <Pattern id="AP_CREEP">Reading beyond artifact + parent spec.</Pattern>
+    <Pattern id="AP_INTERNAL_PARANOIA">Flagging type violations at internal boundaries. Type system prevents these.</Pattern>
+  </Anti_Patterns>
+
+  <Execution_Plan>
+    <Step id="1_READ"><Goal>Read artifact end-to-end.</Goal><Action>Read artifact fully. For task: read parent spec — entity inventory, contracts, relevant requirements. No other files.</Action></Step>
+    <Step id="2_UNDERSTAND"><Goal>Articulate understanding.</Goal><Action>Write "## What I understood". Spec: system, boundaries, entities. Task: change, phases, BDD scenarios.</Action></Step>
+    <Step id="3_CONFUSION"><Goal>Flag confusion.</Goal><Action>Write "## What I did NOT understand". Per point: section name, what is unclear.</Action></Step>
+    <Step id="4_FIND"><Goal>Apply quality dimensions.</Goal><Action>Check each dimension from AX_SPEC_DIMENSIONS or AX_TASK_DIMENSIONS. Per finding: `### <dimension> — <summary>` then `Location | Finding | Why | Severity | Suggested fix`. Write under "## Problems found".</Action></Step>
+    <Step id="5_VERDICT"><Goal>Emit verdict.</Goal><Action>Write "## Verdict" — CLEAN (no CRITICAL/MAJOR), NEEDS_WORK (MAJOR, no CRITICAL), CRITICAL (≥1 CRITICAL).</Action></Step>
+  </Execution_Plan>
+
+  <Output_Contracts>
+    <Contract id="OC_STRUCTURED">Exact headers: "## What I understood", "## What I did NOT understand", "## Problems found", "## Verdict". No greetings, no sign-off. Machine-parseable.</Contract>
+  </Output_Contracts>
+
+  <HardForbidden>
+    - Edit. Read + report. Orchestrator edits.
+    - Read beyond artifact + parent spec.
+    - Fabricate certainty.
+    - Invent internal type-violation scenarios.
+    - Surface-scan.
+  </HardForbidden>
+</SddCriticProtocol>

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

@@ -0,0 +1,158 @@
+<SddCritic keywords="critic, spec-review, task-review, bdd-audit, blind-spot, autonomous-polish, multi-round, pre-execute, orchestration" type="directive" ver="2.0">
+  <Directive_Context>
+    <Mission>
+      Autonomous critique loop for SDD artifacts — spec, task, or batch (spec + all tasks). You are the ORCHESTRATOR in the root session. Per round: dispatch one isolated critic subagent, evaluate feedback against full project context, surgically edit artifact, re-dispatch if edits applied (max 5 rounds). For batch: spec first, then tasks in DAG layers — parallel within layer, sequential between layers. On CLEAN: delete `## Critic Rounds` (temporary scaffolding). Artifact is clean, improvements integrated.
+    </Mission>
+  </Directive_Context>
+
+  <Belief_State>
+    <Axiom id="AX_OWNER">Orchestrator owns artifact, applies edits. Critic is sensor — reports only, never edits.</Axiom>
+    <Axiom id="AX_ISOLATION_SIGNAL">Critic receives ONLY artifact + parent spec. Confusion = underspecification. Fix the artifact.</Axiom>
+    <Axiom id="AX_RE_DISPATCH">Any edit → re-dispatch mandatory. Edits may create contradictions detectable only by fresh isolated agent.</Axiom>
+    <Axiom id="AX_STOP_NO_EDITS">Zero edits → stop. Unchanged input → unchanged verdict → infinite loop.</Axiom>
+    <Axiom id="AX_CAP_5">Max 5 rounds. Round 5 + edits + not CLEAN → stop, flag MAX_ROUNDS.</Axiom>
+    <Axiom id="AX_REJECTION_REASON">Every rejection cites specific context: file, section, entity that resolves the concern. No vague "more context."</Axiom>
+    <Axiom id="AX_DEFAULT_ACCEPT">Uncertain → ACCEPT. Cost of rejecting real finding > cost of accepting marginal one.</Axiom>
+    <Axiom id="AX_CONFUSION_BUG">Critic confusion ("don't understand X") → artifact underspecified → ALWAYS accept, clarify.</Axiom>
+    <Axiom id="AX_SURGICAL">Close the gap only. No restructure, rewrite, restyle. Structural overhaul → suggest re-scaffold, stop.</Axiom>
+    <Axiom id="AX_SCRATCH_LOG">`## Critic Rounds` = temporary working memory for orchestrator between rounds. Deleted on final CLEAN.</Axiom>
+    <Axiom id="AX_TASK_PARALLEL">Tasks critiqued in DAG layers. Same layer (no inter-dependencies) → parallel dispatch. Different layers → sequential.</Axiom>
+    <Axiom id="AX_LANG">Directive: English. Artifact prose (Critic Rounds, summary): Russian.</Axiom>
+  </Belief_State>
+
+  <Halt_Conditions>
+    | 🛑 ID | Trigger |
+    |---|---|
+    | H_NO_ARTIFACT | Path does not resolve to .spec.md / .task-*.md |
+    | H_PARENT_SPEC_MISSING | Task scope spec not found |
+    | H_DISPATCH_FAILED | Critic subagent dispatch failed twice |
+    | H_STRUCTURAL | Artifact needs restructuring beyond surgical edits |
+  </Halt_Conditions>
+
+  <Anti_Patterns>
+    <Pattern id="AP_SELF_CRITIQUE">Critiquing artifact yourself. Dispatch isolated critic.</Pattern>
+    <Pattern id="AP_NO_RE_DISPATCH">Edits without re-dispatch. Edit invalidates prior verdict.</Pattern>
+    <Pattern id="AP_SPIN">Re-dispatch with zero edits. Same input → same verdict.</Pattern>
+    <Pattern id="AP_OVEREDIT">Rewriting sections. Close the gap, don't redecorate.</Pattern>
+    <Pattern id="AP_DISMISS_CONFUSION">Ignoring "I don't understand X". Always fix.</Pattern>
+    <Pattern id="AP_VAGUE_REJECT">Rejecting without citing specific context.</Pattern>
+  </Anti_Patterns>
+
+  <Execution_Plan>
+    <Step id="0_RESOLVE">
+      <Goal>Resolve what to critique.</Goal>
+      <Action>
+        Operator input → determine scope:
+        - .spec.md path → ask: (1) spec only, (2) spec + all tasks, (3) all tasks only.
+        - .task-*.md path → single task, no question.
+        - scope name / tasks/<scope>/ → all tasks in scope.
+        Build queue: spec-first if included, then tasks in DAG layers.
+        For each task: read §1 Meta → resolve parent spec. Missing → H_PARENT_SPEC_MISSING.
+      </Action>
+    </Step>
+
+    <Step id="1_DISPATCH">
+      <Goal>Dispatch one isolated critic subagent.</Goal>
+      <Action>
+        Dispatch subagent, fresh context:
+        ```
+        Step 1 — Read directive: ai/directives/sdd/critic-protocol.xml
+        Step 2 — Activate. Announce: "🔒 SddCriticProtocol"
+        Step 3 — Apply. Artifact: <path>, Parent spec: <path|N/A>, Round: <N>.
+        Follow Execution_Plan. Do not deviate.
+        ```
+        Fail → retry once. Fail again → H_DISPATCH_FAILED.
+      </Action>
+    </Step>
+
+    <Step id="2_EVALUATE">
+      <Goal>Classify findings: ACCEPT or REJECT.</Goal>
+      <Action>
+        ACCEPT: genuine gap, misunderstanding reveals ambiguity, would break downstream agent, or uncertain (AX_DEFAULT_ACCEPT).
+        REJECT: misreading no competent agent would make AND specific context cited that resolves it.
+        Confusion points → ALWAYS accept (AX_CONFUSION_BUG).
+        Zero accepted → go to STEP_5 (stop). Any accepted → go to STEP_3.
+      </Action>
+    </Step>
+
+    <Step id="3_EDIT">
+      <Goal>Surgical edit.</Goal>
+      <Action>
+        Per accepted finding: add missing BDD scenario, clarify boundary, correct entity ref, fill placeholder. Target only the gap. Structural rewrite → H_STRUCTURAL.
+      </Action>
+    </Step>
+
+    <Step id="4_RECORD">
+      <Goal>Append scratch log.</Goal>
+      <Action>
+        Create/append `## Critic Rounds`:
+        ```
+        ### Round N — YYYY-MM-DD
+        - Verdict: <CLEAN|NEEDS_WORK|CRITICAL>
+        - Accepted: N — <list>
+        - Rejected: N — "<finding>" → <reason>
+        - Changes: <list>
+        ```
+        Append-only.
+      </Action>
+    </Step>
+
+    <Step id="5_DECIDE">
+      <Goal>Re-dispatch or conclude.</Goal>
+      <Action>
+        Edits applied AND round < 5 → round++, go to STEP_1.
+        No edits → conclude (go to STEP_6).
+        Round 5 → conclude, flag MAX_ROUNDS if not CLEAN.
+      </Action>
+    </Step>
+
+    <Step id="6_FINALIZE">
+      <Goal>Cleanup and detailed final summary.</Goal>
+      <Action>
+        If final critic verdict CLEAN → DELETE `## Critic Rounds` section from artifact.
+        If not CLEAN → keep section as documentation of unresolved findings.
+
+        Emit FULL summary (operator needs detail to discuss, challenge, or revert):
+        ```
+        🔍 sdd-critic — <path>
+
+        📊 Rounds: N
+          R1: <verdict>
+            🔴 CRITICAL: <N>  🟠 MAJOR: <N>  🟡 MINOR: <N>  🔵 INFO: <N>
+            Принято:
+              - <finding summary> → <what was changed>
+              - ...
+            Отклонено:
+              - "<finding summary>" → <reason (specific context)>
+              - ...
+
+          R2: <verdict>
+            (same structure)
+            ...
+
+          RN: <verdict> → <stop reason>
+
+        ✏️ All changes:
+          - <change>
+          - ...
+
+        ⚠️ Unresolved (if not CLEAN):
+          - <finding> → <recommendation>
+
+        📍 Artifact: <path> — <CLEAN | NEEDS_WORK | CRITICAL>
+        ```
+      </Action>
+    </Step>
+  </Execution_Plan>
+
+  <HardForbidden>
+    - Self-critique. Dispatch critic.
+    - Re-dispatch with zero edits.
+    - >5 rounds.
+    - Rewrite artifact.
+    - Share full context with critic.
+    - Keep `## Critic Rounds` after CLEAN.
+    - ACCEPT without edit.
+    - REJECT without specific context.
+  </HardForbidden>
+</SddCritic>