gennady 0.8.4-next.3 → 0.8.4-next.8

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

@@ -49,7 +49,7 @@
       Deterministic mechanical checks — file-header presence, Task-ID collision, tracker-sync — are NOT hand-coded here. They live in one tool, `sdd check`, which sdd-check (whole tree) and this directive (scoped) both consume. Single source of mechanical truth → no drift between the two SDD reviewers.
 
       - `sdd check --files <git-diff in-scope files>` → [HEADERS] (`@file`/`@consumers`/`@tasks` presence).
-      - `sdd check --task <Task-ID>` → [TASKID] (collision for that id) + [TRACKER_SYNC] (Meta.Status vs tracker row).
+      - `sdd check --task <Task-ID>` → [TASKID] (collision for that id) + [TRACKER_SYNC] (Meta.Status vs tracker row) + [RULES] (four-section presence in the rules this ticket cites; `rule_findings` is counted apart from `findings` because a shared rule file is not this task's defect).
       - `sdd check <root>` (no flag) → tree-wide [TASKID] orphan refs (epic mode).
 
       Audit still owns everything the tool cannot decide mechanically: semantic `@consumers` resolvability, current-Task-ID identity, append-only `@tasks` regression vs git, section-anchor coverage, and all code-reading checks (closed-world, completeness, rules-compliance, runtime-backing, backflow).
@@ -67,7 +67,7 @@
       | `RULES_CASCADE_MISMATCH` | a phase's `Rules:` list ≠ what scaffolder would derive now from cascade × that phase's `Target Files` + kind |
       | `TASK_ID_DRIFT` | `@tasks` field references non-existent ticket ID (orphan); OR Task-ID duplicated across ticket files (collision); OR `@tasks` field lost prior IDs (regression of append-only) |
       | `BDD_COVERAGE_MISMATCH` | canonical case names in ticket Test Scenario Coverage ≠ real test cases |
-      | `EXECUTION_LOG_INCOMPLETE` | mandatory closing lines missing (`ver` / `DONE` per phase, `DONE` at Round close); OR `intro` line absent for an entity that appears in code but not in module Inventory; OR a previous round was edited (round log is append-only); OR `[x]` line with unreplaced `<…>` placeholder (fabricated done) |
+      | `EXECUTION_LOG_INCOMPLETE` | mandatory closing lines missing (`ver` / `DONE` per phase, `DONE` at Round close); OR `intro` line absent for an entity that appears in code but not in module Inventory; OR a previous round was edited (round log is append-only); OR `[x]` line with unreplaced `<…>` placeholder (fabricated done). Token vocabulary and Round-close shape are decided by `sdd check` [LOG], not by eye: `unknown-token` / `unclosed-round` are findings, `retired-token` / `round-close-no-timestamp` are not (append-only history) |
       | `INSIGHT_BACKFLOW` | Phase agent discovered something that changes contract / requirement understanding; should flow back into spec |
       | `STALE_AFTER_PIVOT` | scope spec was reworked in `pivot` mode (Pivot Invalidation List exists) but downstream artifacts named in the list have not been refined / reopened / updated |
       | `RULE_FILE_INCOMPLETE` | activated rule file lacks one of the universal checkable sections (`<BeliefState>` / `<AntiPatterns>` / `<VerificationHooks>` / `<RewardCriteria>`) per `AX_RULES_COMPLIANCE_AGAINST_ACTIVATED_RULES`; audit can partially proceed but the gap blocks full coverage |
@@ -87,10 +87,11 @@
     </Axiom>
 
     <Axiom id="AX_FINDINGS_AS_PROPOSALS">
-      Every finding contains a proposed remediation. Agent does not modify code. Three remediation types:
+      Every finding contains a proposed remediation. Agent does not modify code. Remediation types:
       - `code-fix` — concrete change in code (with location).
       - `spec-update` — concrete spec update (module or scope) with proposed diff.
       - `ticket-update` — ticket update (canonical case names, deferred scope, etc.).
+      - `rule-file-fix` — shared rule/directive/tooling artifact; outside any task, goes to its own ticket.
     </Axiom>
 
     <Axiom id="AX_FINDING_ROUTING">
@@ -108,6 +109,7 @@
       | `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 |
+      | `RULE_FILE_INCOMPLETE` | `rule-file-fix` — the rule file is shared project infrastructure, outside every phase's Target Files. Never `ticket-update` (the ticket cannot fix it, and the paper-fix loops forever), never `phases_to_fix`, never `FAIL` for this task |
       | 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`).
@@ -170,7 +172,7 @@
       - `<VerificationHooks>` → executable check commands
       - `<RewardCriteria>` → ✅ invariants / ❌ forbidden states
 
-      Required sections: `<BeliefState>` / `<AntiPatterns>` / `<VerificationHooks>` / `<RewardCriteria>`. Optional: `<DependsOn>` (only when the rule extends another). Required section missing → `RULE_FILE_INCOMPLETE` (`MAJOR`); audit proceeds with available sections.
+      Section presence is NOT judged by eye — `sdd check --task <Task-ID>` emits `[RULES]` for exactly this ticket's cited rules (per `AX_MECHANICAL_VIA_SDD_CHECK`). Each `INCOMPLETE` row → one `RULE_FILE_INCOMPLETE`, its `missing` column copied verbatim. Audit proceeds with the sections that exist. `<DependsOn>` is optional and unchecked.
 
       **Per (artifact ∈ Round diff, rule ∈ union of all phases' Rules):**
       1. Apply rule's `<Triggers>` / `<ActivationHint>` from `knowledge.xml` to decide if the rule governs this artifact. No match → skip pair.
@@ -458,7 +460,7 @@
     <Contract id="FINDING_FORMAT">
       ```markdown
       ### <🔴|🟠|🟡|🔵> F-NNN — <short title>
-      - **Type:** CLOSED_WORLD_DRIFT | COMPLETENESS_GAP | RUNTIME_BACKING_VIOLATION | RULES_COMPLIANCE_VIOLATION | RULES_CASCADE_MISMATCH | TASK_ID_DRIFT | BDD_COVERAGE_MISMATCH | EXECUTION_LOG_INCOMPLETE | STALE_AFTER_PIVOT | INSIGHT_BACKFLOW
+      - **Type:** CLOSED_WORLD_DRIFT | COMPLETENESS_GAP | RUNTIME_BACKING_VIOLATION | RULES_COMPLIANCE_VIOLATION | RULES_CASCADE_MISMATCH | TASK_ID_DRIFT | BDD_COVERAGE_MISMATCH | EXECUTION_LOG_INCOMPLETE | STALE_AFTER_PIVOT | INSIGHT_BACKFLOW | RULE_FILE_INCOMPLETE
       - **Severity:** 🔴 BLOCKER | 🟠 MAJOR | 🟡 MINOR | 🔵 INFO
       - **Confidence:** HIGH | MEDIUM | LOW
       - **Status:** 📂 open | ⚠️ operator-acknowledged | ✅ resolved
@@ -482,7 +484,7 @@
 
       ```
       @audit task=<Task-ID> round=<N> mode=<per-task|epic> status=<PASS|PASS_RISK|FAIL> counts=B<n>·M<n>·m<n>·I<n> phases_to_fix=[<P<N>>,...]
-      F-<NN> | sev=<B|M|m|I> | type=<TYPETOKEN> | conf=<H|M|L> | loc=<path:line|—> | phase=<P<N>|—> | src=<spec/ticket/rule anchor|—> | route=<spec-edit|ticket-reopen|ticket-update|decision-log|code-fix> | act=<one-line action, no newlines>
+      F-<NN> | sev=<B|M|m|I> | type=<TYPETOKEN> | conf=<H|M|L> | loc=<path:line|—> | phase=<P<N>|—> | src=<spec/ticket/rule anchor|—> | route=<spec-edit|ticket-reopen|ticket-update|decision-log|code-fix|rule-file-fix> | act=<one-line action, no newlines>
       F-<NN> | …
       ~applied | <target> | <one-line description of inline change>   (optional, repeat per applied change)
       ```
@@ -490,8 +492,8 @@
       Token vocabulary:
       - `sev`: `B`=BLOCKER, `M`=MAJOR, `m`=MINOR, `I`=INFO.
       - `conf`: `H`=HIGH, `M`=MEDIUM, `L`=LOW.
-      - `type`: one of `CLOSED_WORLD_DRIFT` | `COMPLETENESS_GAP` | `RUNTIME_BACKING_VIOLATION` | `RULES_COMPLIANCE_VIOLATION` | `RULES_CASCADE_MISMATCH` | `TASK_ID_DRIFT` | `BDD_COVERAGE_MISMATCH` | `EXECUTION_LOG_INCOMPLETE` | `STALE_AFTER_PIVOT` | `INSIGHT_BACKFLOW`.
-      - `route`: one of `spec-edit` | `ticket-reopen` | `ticket-update` | `decision-log` | `code-fix` (per `AX_FINDING_ROUTING`).
+      - `type`: one of `CLOSED_WORLD_DRIFT` | `COMPLETENESS_GAP` | `RUNTIME_BACKING_VIOLATION` | `RULES_COMPLIANCE_VIOLATION` | `RULES_CASCADE_MISMATCH` | `TASK_ID_DRIFT` | `BDD_COVERAGE_MISMATCH` | `EXECUTION_LOG_INCOMPLETE` | `STALE_AFTER_PIVOT` | `INSIGHT_BACKFLOW` | `RULE_FILE_INCOMPLETE`.
+      - `route`: one of `spec-edit` | `ticket-reopen` | `ticket-update` | `decision-log` | `code-fix` | `rule-file-fix` (per `AX_FINDING_ROUTING`).
       - `act` text: Russian operator-facing per `AX_OPERATOR_LANGUAGE` (this is operator-facing artifact text), single line, no pipe character.
       - `status` `PASS_RISK` = PASS_WITH_ACKNOWLEDGED_RISKS.
 

package/ai/directives/sdd/phase-execution-protocol.xml

@@ -28,6 +28,8 @@
   <BeliefState>
     <Axiom id="AX_PHASE_SCOPE_LOCK">
       Touch only this phase's `Target Files`. Reading other files (specs, sibling-phase code, rule files cited in this phase's Rules list) is allowed and expected. Writing anywhere outside this phase's Target Files → `H_OUT_OF_PHASE_WRITE`. Operator decides via re-planning or new task.
+
+      This bounds ownership of verification failures too. A repo-wide gate that fails inside ANOTHER phase's `Target Files` is that phase's work: do not write there, do not call it resolved, do not treat it as your blocker. Record it in Handoff `open:` and continue. Everywhere else the failure is yours — including a file you never opened whose build your diff broke. Nothing outside this ticket's phases is covered by either case: that is `AX_BLOCKER_ESCALATION`.
     </Axiom>
 
 
@@ -73,7 +75,7 @@
 
     <Axiom id="AX_PERMITTED_BASH_COMMANDS">
       Phase agent may ONLY run these bash commands:
-      - **Must run:** `<sdd-path> verify <target-files>` — MANDATORY. Auto-discovers and runs typecheck, gennady DBC lint, linter, tests, and format check for the project. Runs before §5 commands. **RUN-ALL**: every gate executes regardless of previous failures; failures accumulate. **SUPPRESS-ON-SUCCESS**: passing gates produce zero output; only failed gates dump their command, exit code, and captured output. On all-pass: single summary line. Failing gate → fix and re-run before EMIT_HANDOFF. Log each passing gate on a separate `ver` line.
+      - **Must run:** `<sdd-path> verify <target-files>` — MANDATORY. Auto-discovers and runs typecheck, gennady DBC lint, linter, tests, and format check for the project. Runs before §5 commands. **RUN-ALL**: every gate executes regardless of previous failures; failures accumulate. **SUPPRESS-ON-SUCCESS**: passing gates produce zero output; only failed gates dump their command, exit code, and captured output. On all-pass: single summary line. Failing gate → fix and re-run before EMIT_HANDOFF. ONE `ver` line per invocation (see `STEP_5_VERIFY`).
       - **Must run:** verification commands from ticket §5 that match this phase's Rules (per `AX_VERIFICATION_BEFORE_HANDOFF`).
       - **May run:** `ls <dir>` for targeted recon (NOT `-la` or recursive); `tsc --noEmit` after code changes; `node --test <specific test file>` for test-kind phases; `date -u +%Y-%m-%dT%H:%M:%SZ` for timestamps.
       - **May run:** `<sdd-path> extract <file> <NAME>` — extract anchored section from ticket/spec.
@@ -280,11 +282,9 @@
     <Step id="STEP_5_VERIFY">
       <Goal>Run MANDATORY sdd verify on target files, then ticket §5 commands. Log only final results.</Goal>
       <Action>
-         1. **MANDATORY — sdd verify gate:** Run `<sdd-path> verify <target-files>`. This auto-discovers and executes typecheck, gennady DBC lint, linter, tests, and format check from package.json scripts. **RUN-ALL**: every gate executes regardless of previous failures; failures accumulate. **SUPPRESS-ON-SUCCESS**: passing gates produce zero output; only failed gates dump their command, exit code, and captured output. On all-pass: single summary line. If any gate fails → fix ALL failures and re-run the full `sdd verify` again. Do NOT proceed to EMIT_HANDOFF until all gates pass.
-
-            **⚠️ ERROR OWNERSHIP (MANDATORY):** Every error surfaced by `<sdd-path> verify` is an error of the current session. The agent is the sole actor in this repository during the session. No error may be dismissed as «not my file», «pre-existing», «someone else's problem», or «out of scope». If `<sdd-path> verify` reports a failure in ANY file — edited, created, never touched, outside Target Files, config, spec, task, generated — the agent owns it and MUST fix it. There is no «their error». There are only errors the agent has not yet fixed. Verification is holistic; so is ownership. Fix everything.
+         1. **MANDATORY — sdd verify gate:** Run `<sdd-path> verify <target-files>`. This auto-discovers and executes typecheck, gennady DBC lint, linter, tests, and format check from package.json scripts. **RUN-ALL**: every gate executes regardless of previous failures; failures accumulate. **SUPPRESS-ON-SUCCESS**: passing gates produce zero output; only failed gates dump their command, exit code, and captured output. On all-pass: single summary line. Any failure is yours to fix unless `AX_PHASE_SCOPE_LOCK` puts the file in another phase's hands — «pre-existing» and «not my file» are not available for the rest. Fix, re-run the full `sdd verify`, and do not proceed to EMIT_HANDOFF while a gate you own is red.
 
-            Each passing gate gets its own `ver` line.
+            Log ONE `ver` line for this invocation, quoting the tool's own verdict — `sdd verify` names only the gates that FAILED, so a per-gate «pass» line reports a result it never printed. That is `fabricated-verification`, same BLOCKER class as logging a §5 command you did not run.
         2. Then run ticket §5 commands per existing logic below.
         2. **MANDATORY (PROTOCOL):** Execute EACH such §5 command **verbatim — the exact string from the ticket**. No substitutions, no "equivalents", no narrower variants. If §5 says `npm run check`, run `npm run check` (not `npx vitest`, not `tsc --noEmit`, not `<sdd-path> verify`). This is the Canonical Gate (per `AX_VERIFICATION_BEFORE_HANDOFF`); fabrication is a BLOCKER-class finding at audit.
         3. **Supplemental (OPTIONAL):** You MAY additionally run `<sdd-path> verify <Target Files>` or `tsc --noEmit` for narrower diagnostics — useful for fast feedback or DBC lint. These do NOT replace §5; they add to it. Each supplemental run is logged on its own `ver` line with its real command.

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

@@ -229,7 +229,9 @@
     </Axiom>
 
     <Axiom id="AX_AUDIT_HOOK">
-      Round is complete only after `audit` returns PASS. `sdd-execute` orchestrator dispatches audit-subagent automatically after the last phase of a Round closes — operator does not invoke audit manually. `[x] DONE` on the ticket is mechanical close, not verification. Until audit PASS, dependents are blocked.
+      Round is complete only after `audit` returns PASS. `sdd-execute` orchestrator dispatches audit-subagent automatically after the last phase of a Round closes — operator does not invoke audit manually.
+
+      Closing the Round does NOT set `[x] DONE`. The ticket stays `[~] IN_PROGRESS` from Round close until audit PASS, and only then becomes `[x] DONE`. So `[x] DONE` means verified — one meaning, and the one dependents rely on: pickability reads that status, and a task whose audit has not run (or has failed) must not read as pickable.
     </Axiom>
 
     <Axiom id="AX_PHASES_DECLARED_IN_HEADER">
@@ -714,7 +716,7 @@
       ⛔ `[x]` line with any unreplaced `<…>` literal = fabricated done → `EXECUTION_LOG_INCOMPLETE` (BLOCKER).
 
       ### Post-task Hook
-      Per `AX_AUDIT_HOOK`. After last phase of a Round closes, the orchestrator dispatches `sdd-audit`. Until audit returns PASS, Round is closed-but-unverified and dependents are blocked.
+      Per `AX_AUDIT_HOOK`. After last phase of a Round closes, the orchestrator dispatches `sdd-audit`. Round close leaves the ticket `[~] IN_PROGRESS`; audit PASS is what sets `[x] DONE`. Until then dependents are blocked, and the status says so.
 
       ## High-Level DAG
       Cross-scope edges + integration tickets only. Intra-scope DAGs live in per-scope READMEs.

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

@@ -81,10 +81,16 @@ Parse `Dependencies:` from each task ticket planning surface. Topological sort.
 
 From scan [TASKS] output: check `placeholders` column for any task with >0. Flag tasks where placeholders > 0 even if status DONE. Also inspect `warnings` column for `no-execlog-section` or `anchors-mismatch`.
 
+Token vocabulary and Round-close shape come from `sdd check` [LOG] — do not re-read logs by hand. `unknown-token` (outside the scaffold table) and `unclosed-round` (a Round close with no ticked DONE) → FAIL. `retired-token` (valid before the vocabulary was consolidated) and `round-close-no-timestamp` → INFO: rounds are append-only, so history cannot be rewritten to satisfy a later rule.
+
 ### Check 5b — Task-ID Integrity (from `sdd check` [TASKID])
 
 Read the [TASKID] section of `sdd check`. `collision` (one Task-ID on ≥2 ticket files) → FAIL (BLOCKER). `orphan` (a code `@tasks: TSK-NN` with no ticket file) → FAIL. Empty section → PASS. Same tool sdd-audit STEP_2_5 uses.
 
+### Check 5c — Rule File Schema (from `sdd check` [RULES])
+
+Read the [RULES] section. Each `verdict=INCOMPLETE` row is a rule file missing one of the four checkable sections; the `missing` column names them. Report as INFO with the file list, **not** as a tree FAIL: these are shared project artifacts, tracked by `rule_findings` separately from `findings` for exactly that reason. Fixing them is its own ticket, never a task reopen.
+
 ### Check 6 — File Headers (from `sdd check --files`)
 
 Pass recently modified source files to the shared checker instead of sampling by hand:
@@ -134,8 +140,9 @@ First: Self-Reflection. Then: Mechanical Checks. Use compact single-line-per-che
 
 Rules for VERDICT line:
 
-- All 8 checks PASS AND 0 protocol violations → `✅ CLEAN — artifact tree is consistent, next pickable: TSK-NN`
-- All 8 checks PASS AND 0 violations but some tasks deferred/TODO → `✅ CLEAN — <N> tasks remaining in queue`
+- All checks PASS AND 0 protocol violations → `✅ CLEAN — artifact tree is consistent, next pickable: TSK-NN`
+- All checks PASS AND 0 violations but some tasks deferred/TODO → `✅ CLEAN — <N> tasks remaining in queue`
+- Check 5c findings are INFO — they never move the verdict off `✅ CLEAN`; append `· <N> rule file(s) incomplete` to the line instead
 - Any FAIL check OR protocol violations → `❌ NOT READY — <N> issue(s) require attention`
 - Checks skipped (marked `—`) → treat as PASS for verdict unless evidence of gap exists
   </Output>

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

@@ -95,16 +95,16 @@ Pause path (distinguish from failure — skill is awaiting operator, not broken)
 4.  **Close Round** — append to ticket section 7:
     ```
     #### Round close
-    - [x] `<ts>` sync <scope>+root
     - [x] `<ts>` DONE
     ```
-    Set ticket Meta Status → `[x] DONE`.
+    Set ticket Meta Status → `[~] IN_PROGRESS`. **Not `[x] DONE` — the round is closed, not verified.** `DONE` is set in step 6, and only on audit PASS. Dependents pick on `DONE`, so setting it here advertises a task the audit has not seen yet.
 
 4a. **Sync Trackers** (MANDATORY, cannot skip):
 
-- Read `tasks/<scope>/README.md`. Find the Tracker row for this Task-ID. Set its Status → `[x] DONE`. Write back.
-- Read `tasks/README.md` Tracker Index. Update the scope's aggregate counts (done/total). Write back.
+- Read `tasks/<scope>/README.md`. Find the Tracker row for this Task-ID. Set its Status to the ticket's current Meta Status. Write back.
+- Read `tasks/README.md` Tracker Index. Update the scope's aggregate counts (done/total) — a task counts as done only at `[x] DONE`. Write back.
 - Verify: re-read both files, confirm the changes took effect. If not → retry once.
+- Run this step again after step 6 sets the final status.
 
 5.  **Dispatch AUDIT** (MANDATORY, always runs). Dispatch ONE subagent (`subagent_type: general-purpose`, **`model: "haiku"`** — audit is mechanical verification + fact-checking against artifacts; sonnet capability is overkill, haiku is faster and cheaper for this read-heavy task). Include in prompt the SDD tooling location: `~/Developer/gennady/ai/skills/sdd-execute/scripts/sdd` (audit may use `lint`, `verify`, `check-blockers` subcommands). With this prompt:
 
@@ -129,9 +129,9 @@ Pause path (distinguish from failure — skill is awaiting operator, not broken)
     Wait for return. If dispatch fails → retry once. If fails again → mark task FAILED.
 
 6.  **Branch on audit status:**
-    - `PASS` or `PASS_WITH_ACKNOWLEDGED_RISKS` → ticket verified; jump to step 9 (summary).
+    - `PASS` or `PASS_WITH_ACKNOWLEDGED_RISKS` → ticket verified. **Only now** set Meta Status → `[x] DONE` and re-run step 4a so the trackers and the aggregate counts follow. Jump to step 9 (summary).
     - `FAIL` AND `audit_attempt = 1` → step 7 (resolve findings).
-    - `FAIL` AND `audit_attempt = 2` → STOP; jump to step 9 (summary with FAIL after 2 attempts).
+    - `FAIL` AND `audit_attempt = 2` → cap exhausted. Set Meta Status `[!] BLOCKED`, log `🛑 BLOCKED: audit-cap-exhausted` whose `💬 unblock:` line is the literal command `/sdd-execute <TSK-NN> --new-audit-session`, sync trackers, jump to step 9.
 
 7.  **Resolve audit findings (max one retry, total 2 audit attempts):**
 
@@ -197,7 +197,8 @@ Pause path (distinguish from failure — skill is awaiting operator, not broken)
 - Writing code, audit reports, or phase blocks in Execution Log. (Subagents do.)
 - Skipping audit after all phases DONE. Audit dispatch is mandatory; this is the safety net.
 - Sharing context between phase subagents and audit subagent. Each gets a fresh prompt; orchestrator threads only typed Handoff payloads.
-- Audit retry beyond 2 total attempts. Hard cap.
+- Audit retry beyond 2 attempts per session. Hard cap. Only the operator's literal `--new-audit-session` arg resets it — never your reading of «доделай» / «продолжай» / «finish it», which does not distinguish «lift the cap» from «finish what is already unblocked». No token → print the command and wait.
+- Writing a `✅ RESOLVED` marker for a blocker that is not resolved. `check-blockers` counts markers, so one makes it dispatch — that is a bug you can trigger, not permission you can grant. The marker records a fact; fabricating it is the same class as a fabricated `ver` line.
 - Re-running phases not flagged in `phases_to_fix`. The map finding-location → phase is the contract; do not "just re-run everything".
 - Auto-reopening on phase BLOCKED/FAIL. Only on audit FAIL after all phases DONE the retry kicks in.
 - Parallel dispatch of phases of the SAME task. Phases are sequential by declared `Deps`. Cross-task parallelism is the job of `sdd-execute-batch`.

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

@@ -5,19 +5,37 @@
 #            header presence, Task-ID integrity, or tracker sync. Pure function of files on disk.
 #
 # Three modes:
-#   check.sh [project-root]          — whole tree: TASKID + TRACKER_SYNC (all tickets) + HEADERS (all marker-bearing src)
-#   check.sh --task <TSK-NN> [root]  — one ticket: TASKID (collision/orphan-for-its-refs) + TRACKER_SYNC for that id
+#   check.sh [project-root]          — whole tree: TASKID + TRACKER_SYNC (all tickets) + RULES (all rule files)
+#   check.sh --task <TSK-NN> [root]  — one ticket: TASKID + TRACKER_SYNC for that id + RULES for its cited rules
 #   check.sh --files <f1> [f2 ...]   — header-trio presence for an explicit file list (audit passes its git-diff scope)
 #
 # Output sections (TSV, machine-readable, stable):
 #   [HEADERS]      — file \t has_file \t has_consumers \t has_tasks \t verdict(OK|PARTIAL|NONE)
 #   [TASKID]       — kind(orphan|collision) \t id \t detail
 #   [TRACKER_SYNC] — task_id \t ticket_status \t tracker_status \t match(YES|NO|NO_ROW)
+#   [RULES]        — file \t belief \t anti \t hooks \t reward \t verdict(OK|INCOMPLETE) \t missing
+#   [LOG]          — ticket \t round \t line \t kind \t token \t detail
+#                    kinds: unknown-token | unclosed-round        (counted as findings)
+#                           retired-token | round-close-no-timestamp (informational: append-only
+#                           history and cosmetics never fail a tree)
 #   [SUMMARY]      — key=value totals + findings count
 #
+# [RULES] implements the mechanical half of AX_RULES_COMPLIANCE_AGAINST_ACTIVATED_RULES: a rule file
+# must expose <BeliefState> / <AntiPatterns> / <VerificationHooks> / <RewardCriteria>. Detection is a
+# tolerant opening-tag scan, NOT an XML parse — these files are HTML-like by design and carry prose
+# such as `<Target Files>` and `Meta<typeof Button>` that no XML parser accepts.
+#
+# Rule files are the non-`*.directive.xml` entries of the cascade categories (coding / testing / infra),
+# in the project and in plugin directive trees. `*.directive.xml` are protocols, not rules, and are
+# exempt. Tree mode scans every rule file; task mode scans only the ones that ticket's phases cite —
+# the "activated" set the axiom is written against.
+#
+# Rule findings are counted SEPARATELY from task findings (`rule_findings=`): a shared rule file is
+# project infrastructure that no single task owns or may edit, so it must not decide a task's verdict.
+#
 # Exit codes:
 #   0 — all checks clean (zero findings)
-#   3 — one or more findings (desync / orphan / collision / partial-or-missing header)
+#   3 — one or more findings (desync / orphan / collision / partial-or-missing header / incomplete rule)
 #   2 — structural failure (bad root / not an SDD project)
 #   4 — bad invocation
 
@@ -82,6 +100,7 @@ EOF
 esac
 
 FINDINGS=0
+RULE_FINDINGS=0
 
 # ---------------------------------------------------------------------------
 # Mode: --files  → HEADERS only
@@ -227,6 +246,148 @@ done <<< "$TASK_FILES"
 # is a policy (task-generated vs hand-authored), not a mechanical fact. Header presence
 # is meaningful only against a known in-scope file set — provided by audit via --files.
 
+# ---------------------------------------------------------------------------
+# [RULES] — activated rule files expose the four checkable sections
+# ---------------------------------------------------------------------------
+
+printf '\n[RULES]\n# file\tbelief\tanti\thooks\treward\tverdict\tmissing\n'
+
+# Cascade categories only; `*.directive.xml` are protocols, not rules.
+rule_files_in_tree() {
+    find -L "$ROOT_ABS/ai/directives" "$ROOT_ABS"/plugins/*/directives \
+        -type d -name node_modules -prune -o \
+        -type f -name '*.xml' ! -name '*.directive.xml' -print 2>/dev/null \
+        | grep -E '/(coding|testing|infra)/[^/]+\.xml$' | sort -u || true
+}
+
+# Task mode: the rules this ticket's phases actually cite (the "activated" set).
+rule_files_for_task() {
+    local ticket
+    ticket=$(grep -l "^- \*\*Task-ID:\*\* $TASK_ID\$" $TASK_FILES 2>/dev/null | head -1)
+    [[ -z "$ticket" ]] && return
+    grep -ohE '(ai/directives|plugins/[a-z0-9-]+/directives)/[a-z0-9-]+/[a-z0-9._-]+\.xml' "$ticket" \
+        | grep -vE '\.directive\.xml$' | sort -u \
+        | while IFS= read -r rel; do
+            [[ -f "$ROOT_ABS/$rel" ]] && printf '%s\n' "$ROOT_ABS/$rel"
+          done
+}
+
+if [[ "$MODE" == "task" ]]; then
+    RULE_FILES=$(rule_files_for_task)
+else
+    RULE_FILES=$(rule_files_in_tree)
+fi
+
+if [[ -z "$RULE_FILES" ]]; then
+    printf '# none%s\n' "$([[ "$MODE" == task ]] && echo " — ticket cites no rule files")"
+else
+    while IFS= read -r rf; do
+        [[ -z "$rf" ]] && continue
+        b=0; a=0; h=0; r=0; missing=""
+        grep -q '<BeliefState' "$rf" && b=1 || missing="${missing}BeliefState,"
+        grep -q '<AntiPatterns' "$rf" && a=1 || missing="${missing}AntiPatterns,"
+        grep -q '<VerificationHooks' "$rf" && h=1 || missing="${missing}VerificationHooks,"
+        grep -q '<RewardCriteria' "$rf" && r=1 || missing="${missing}RewardCriteria,"
+        if [[ -z "$missing" ]]; then
+            printf '%s\t1\t1\t1\t1\tOK\t-\n' "${rf#$ROOT_ABS/}"
+        else
+            printf '%s\t%d\t%d\t%d\t%d\tINCOMPLETE\t%s\n' "${rf#$ROOT_ABS/}" "$b" "$a" "$h" "$r" "${missing%,}"
+            RULE_FINDINGS=$((RULE_FINDINGS+1))
+        fi
+    done <<< "$RULE_FILES"
+fi
+
+# ---------------------------------------------------------------------------
+# [LOG] — Execution Log token vocabulary + Round-close shape
+# ---------------------------------------------------------------------------
+
+printf '\n[LOG]\n# ticket\tround\tline\tkind\ttoken\tdetail\n'
+
+# `retired` tokens were valid before the vocabulary was consolidated. Rounds are append-only, so
+# their presence in an old round is history, not a defect — they are reported and NOT counted.
+# Anything outside both sets is `unknown-token` and IS counted.
+LOG_TMP="$(mktemp -t sdd-check-log.XXXXXX)"
+trap 'rm -f "$COLLISION_TMP" "$LOG_TMP"' EXIT
+
+while IFS= read -r f; do
+    [[ -z "$f" ]] && continue
+    if [[ "$MODE" == "task" ]]; then
+        [[ "$(sdd_lib_task_id "$f")" == "$TASK_ID" ]] || continue
+    fi
+    awk -v ticket="${f#$ROOT_ABS/}" '
+        BEGIN {
+            split("intro decision tried discovery insight verified ver BLOCKED DONE", v, " ")
+            for (i in v) valid[v[i]] = 1
+            # Retired when the vocabulary was consolidated (scaffold.directive names exactly these).
+            split("sync file test cov rules recon", r, " ")
+            for (i in r) retired[r[i]] = 1
+            # Blocker lifecycle markers are their own shape, not action tokens.
+            valid["🛑"] = 1; valid["✅"] = 1
+            round = "-"; inlog = 0; inclose = 0; closelines = 0; closebad = 0
+        }
+        /^## 7\. Execution Log/ { inlog = 1; next }
+        /^## [0-9]+\./       { if (inlog) inlog = 0 }
+        inlog == 0           { next }
+        /^### Round /        {
+            if (inclose && closelines != 1 && closebad == 0)
+                printf "%s\t%s\t%d\tbad-round-close\t-\texpected exactly one DONE line, found %d\n", ticket, round, closeline, closelines
+            round = $3; inclose = 0; closelines = 0; closebad = 0; next
+        }
+        /^#### Round close/  { inclose = 1; closelines = 0; closebad = 0; closeline = NR; next }
+        /^#### /             {
+            if (inclose && closelines != 1 && closebad == 0)
+                printf "%s\t%s\t%d\tbad-round-close\t-\texpected exactly one DONE line, found %d\n", ticket, round, closeline, closelines
+            inclose = 0; closebad = 0; next
+        }
+        # Token lines: "- [x] `<ts>` <token> ..."  (blocker lines use 🛑 and are matched separately)
+        /^- \[[ x~!]\] `[^`]*` / {
+            rest = $0; sub(/^- \[[ x~!]\] `[^`]*` +/, "", rest)
+            split(rest, w, " "); tok = w[1]
+            sub(/:$/, "", tok)   # a trailing colon is cosmetic, not a different token
+            if (inclose) { if (tok == "DONE") closelines++ }
+            if (tok in valid) next
+            # Every real token is lowercase except BLOCKED / DONE. A capitalised first word is a
+            # sentence from the pre-consolidation prose plan ("Implementation file:", "Tracker
+            # synced:"), which the same consolidation retired.
+            if (tok ~ /^[A-Z]/) {
+                printf "%s\t%s\t%d\tretired-token\t%s\tprose line from the pre-consolidation plan template\n", ticket, round, NR, tok
+                next
+            }
+            if (tok in retired) {
+                printf "%s\t%s\t%d\tretired-token\t%s\tvalid before the vocabulary was consolidated; round is append-only\n", ticket, round, NR, tok
+            } else {
+                printf "%s\t%s\t%d\tunknown-token\t%s\tnot in the scaffold.directive token table\n", ticket, round, NR, tok
+            }
+            next
+        }
+        # A checkbox line inside Round close that carries no timestamped token at all.
+        # Close-block lines that carry no timestamped token. A ticked DONE without a timestamp is
+        # cosmetic drift; an unticked box means the round was never actually closed.
+        inclose == 1 && /^- / {
+            if ($0 ~ /\[x\]/ && $0 ~ /DONE/) {
+                printf "%s\t%s\t%d\tround-close-no-timestamp\tDONE\tclosed, but the `<ts>` is missing\n", ticket, round, NR
+                closelines++
+            } else {
+                printf "%s\t%s\t%d\tunclosed-round\t-\tRound close carries no ticked DONE: %s\n", ticket, round, NR, substr($0, 1, 40)
+                closebad = 1
+            }
+        }
+        END {
+            if (inclose && closelines != 1 && closebad == 0)
+                printf "%s\t%s\t%d\tbad-round-close\t-\texpected exactly one DONE line, found %d\n", ticket, round, closeline, closelines
+        }
+    ' "$f" >> "$LOG_TMP"
+done <<< "$TASK_FILES"
+
+if [[ -s "$LOG_TMP" ]]; then
+    cat "$LOG_TMP"
+    # Informational kinds record history or cosmetics; they must not fail the tree.
+    LOG_FINDINGS=$(awk -F'\t' '$4 != "retired-token" && $4 != "round-close-no-timestamp"' "$LOG_TMP" | grep -c '' || true)
+    FINDINGS=$((FINDINGS + LOG_FINDINGS))
+else
+    printf '# none\n'
+fi
+
 # ---------------------------------------------------------------------------
 # [SUMMARY]
 # ---------------------------------------------------------------------------
@@ -234,5 +395,6 @@ done <<< "$TASK_FILES"
 printf '\n[SUMMARY]\nmode=%s\n' "$MODE"
 [[ "$MODE" == "task" ]] && printf 'task=%s\n' "$TASK_ID"
 printf 'findings=%d\n' "$FINDINGS"
+printf 'rule_findings=%d\n' "$RULE_FINDINGS"
 
-[[ "$FINDINGS" -gt 0 ]] && exit 3 || exit 0
+[[ $((FINDINGS + RULE_FINDINGS)) -gt 0 ]] && exit 3 || exit 0

package/ai/skills/sdd-execute/scripts/lint-artifacts.sh

@@ -4,7 +4,10 @@
 # @contract: AX_BASH_NO_SILENT_EMPTY — never produces empty stdout. On miss → actionable instruction.
 #
 # Why this wrapper exists:
-#   - gennady CLI lives outside the project (canonical: ~/Developer/gennady/cli/gennady.ts).
+#   - gennady CLI may live outside the project; resolution is done at RUNTIME (see resolve_gennady).
+#     It MUST NOT be a bare dev-path literal assigned to a variable: `sync-skills` rewrites dev paths
+#     through PathNormalizer, which turned that assignment into an unquoted two-word command, leaving
+#     the variable unset — every deployed copy then died on `set -u`. Keep this file path-literal-free.
 #   - gennady requires `node --experimental-strip-types` (Node 22+) — the bare `node` invocation is non-obvious.
 #   - gennady returns exit code 0 even when lint reports errors (the failure signal is the literal token
 #     "[linting → failed]" in stdout). We must parse output, not trust exit code.
@@ -23,7 +26,29 @@
 set -uo pipefail
 
 PROG="lint-artifacts"
-GENNADY_CLI=~/Developer/gennady/cli/gennady.ts
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Repo root of a gennady checkout: scripts → sdd-execute → skills → ai → root.
+GENNADY_HOME="${GENNADY_HOME:-$SCRIPT_DIR/../../../..}"
+
+# Runtime resolution — deliberately contains no dev-path literal, so PathNormalizer has
+# nothing to rewrite and the deployed copy behaves identically to the checkout copy.
+GENNADY_ARGV=()
+resolve_gennady() {
+    if command -v gennady &>/dev/null; then
+        GENNADY_ARGV=(gennady)
+        return 0
+    fi
+    if [[ -x "$GENNADY_HOME/node_modules/.bin/tsx" && -f "$GENNADY_HOME/cli/gennady.ts" ]]; then
+        GENNADY_ARGV=("$GENNADY_HOME/node_modules/.bin/tsx" "$GENNADY_HOME/cli/gennady.ts")
+        return 0
+    fi
+    if [[ -x "./node_modules/.bin/gennady" ]]; then
+        GENNADY_ARGV=(./node_modules/.bin/gennady)
+        return 0
+    fi
+    return 1
+}
 
 if [[ $# -lt 1 ]]; then
     cat <<EOF
@@ -38,16 +63,18 @@ EOF
     exit 4
 fi
 
-if [[ ! -f "$GENNADY_CLI" ]]; then
+if ! resolve_gennady; then
     cat <<EOF
 [$PROG] GENNADY_CLI_NOT_FOUND
-  expected at: $GENNADY_CLI
+  tried: gennady on PATH
+         \$GENNADY_HOME/cli/gennady.ts via checkout tsx (GENNADY_HOME=$GENNADY_HOME)
+         ./node_modules/.bin/gennady
 
 Diagnosis: the gennady AST DbC linter is unreachable from this environment.
 
 Required action (ORCHESTRATOR):
-  1. Verify the gennady project is checked out at ~/Developer/gennady.
-  2. If gennady moved → update GENNADY_CLI variable in this script.
+  1. Install it in the project (\`npm i -D gennady\`) or put it on PATH.
+  2. Working from a gennady checkout → export GENNADY_HOME=<checkout-root>.
   3. If on a CI/sandbox without gennady → this is a HARD blocker; phase cannot verify.
      Report to operator: cannot complete phase without DBC contract verification.
 
@@ -65,7 +92,7 @@ tmp_out=$(mktemp -t lint-artifacts.XXXXXX)
 trap 'rm -f "$tmp_out"' EXIT
 
 # Run gennady. We intentionally ignore its exit code (unreliable per contract above).
-npx tsx "$GENNADY_CLI" lint "$@" > "$tmp_out" 2>&1 || true
+"${GENNADY_ARGV[@]}" lint "$@" > "$tmp_out" 2>&1 || true
 
 has_clean=$(grep -c '\[linting → clean\]' "$tmp_out" 2>/dev/null || echo 0)
 has_failed=$(grep -c '\[linting → failed\]' "$tmp_out" 2>/dev/null || echo 0)
@@ -108,7 +135,7 @@ Required action (PHASE AGENT, before EMIT_HANDOFF):
   5. Do NOT EMIT_HANDOFF with lint failures present — that is fabricated DONE.
 
 References:
-  /Users/k.lebedev/Developer/vkt/ai/directives/coding/typescript-rules.xml
+  ai/directives/coding/typescript-rules.xml
   — AX_TAG_USAGE_MATRIX, AX_BASE_CONTRACT_SHAPE, AX_FLAT_JSDOC_FOR_PROPERTIES
 EOF
     exit 2
@@ -135,7 +162,7 @@ Captured output:
 $(cat "$tmp_out" | head -50)
 
 Required action (ORCHESTRATOR):
-  1. Re-read gennady source: ~/Developer/gennady/cli/gennady.ts
+  1. Re-read the gennady LintCommand source in the checkout you resolved above.
   2. Check command output tokens in the LintCommand implementation.
   3. Update this script's parsing to match new tokens.
   4. Until resolved → treat as a HARD blocker; DO NOT assume PASS.

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

@@ -174,7 +174,7 @@ run_cmd() {
 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 ;;
+    gennady)   run_cmd "gennady DBC lint" "gennady lint ${#FILES[@]} files" "$SCRIPT_DIR/lint-artifacts.sh" "${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 ;;

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

@@ -125,12 +125,13 @@ Per-task phase tokens:
                 ```
 
             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.
+               - `BLOCKED` on a repo-wide gate failing in files this ticket does not own → PARK the lane, do not fail it. Parallel lanes share one working tree, so that is usually a sibling lane mid-flight. Resume each parked lane once after the sub-batch drains; still blocked → `✋ AWAITING UNBLOCK`, not `❌ FAILED`.
+               - `BLOCKED` or `FAIL` otherwise → 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`.
+          After all phases DONE: close Round (append `#### Round close` block per `ROUND_CLOSE_FORMAT`: a single `DONE` line). Ticket Status → `[~] IN_PROGRESS` — closed, not verified. Sync trackers to that status. `[x] DONE` is set in step e, on audit PASS only: dependents pick on `DONE`, and a later layer must not start against a task the audit has not seen.
 
            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):
               ```
@@ -153,15 +154,15 @@ Per-task phase tokens:
               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).
+             - `PASS` / `PASS_WITH_ACKNOWLEDGED_RISKS` → task verified. Only now set Ticket Status → `[x] DONE` and re-sync trackers. 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.
+                 PASS → task verified: Ticket Status → `[x] DONE`, re-sync trackers.
+                 FAIL (audit_attempt = 2) → STOP lane; cap exhausted. Meta Status `[!] BLOCKED`, `🛑 BLOCKED: audit-cap-exhausted` with `💬 unblock: /sdd-execute <TSK-NN> --new-audit-session`. Report as `🛑 cap-exhausted`, distinct from `❌ FAILED`. The batch never lifts the cap itself.
 
          — 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.
@@ -202,7 +203,8 @@ Per-task phase tokens:
 - 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.
+- Audit retry beyond 2 attempts per task per session. Hard cap; only the operator's literal `--new-audit-session` arg resets it, and only via the sibling `sdd-execute` skill.
+- Writing a `✅ RESOLVED` marker for a blocker that is not resolved, to get past the `check-blockers` preflight. The marker records a fact, not permission.
 - 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.