@k0t0vich/meta-agents-template 0.1.10 → 0.1.11

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this package are documented in this file.
 
+## 0.1.11 - 2026-03-20
+
+### Added
+- Added a hard pre-implementation command `VERIFY_IMPLEMENTATION_GATE` to enforce task readiness before coding starts.
+- Added canonical Status Agent output contract (6 required sections) and corresponding smoke validation.
+- Added robust empty-repository branch-routing behavior for `meta:task-start --apply` (no-commit bootstrap path).
+
+### Fixed
+- Fixed TrackerGateway local script resolution for `PREPARE_TASK_BRANCH`, `RUN_MR_REVIEW_GATE`, and `VERIFY_IMPLEMENTATION_GATE` in npm-linked execution mode.
+- Enforced structured verifiability schema (`strict`, `statistical`, `human`) for task creation and `SET_STATUS -> IN_PROGRESS`.
+- Expanded local post-publish smoke checks for source repo, generated project, and unborn repository scenarios.
+
 ## 0.1.10 - 2026-03-20
 
 ### Fixed

package/README.md

@@ -83,13 +83,14 @@ my-project/
 1. `CREATE_TASK`
 2. `PREPARE_TASK_BRANCH`
 3. `SET_STATUS`
-4. `RUN_REVIEW_GATE`
-5. `COMMIT_BY_NAME`
-6. `RUN_MR_REVIEW_GATE`
-7. `ASSIGN_SPRINT`
-8. `PREPARE_RELEASE_NOTE`
-9. `MARK_TASKS_PUBLISH`
-10. `STATUS_SNAPSHOT`
+4. `VERIFY_IMPLEMENTATION_GATE`
+5. `RUN_REVIEW_GATE`
+6. `COMMIT_BY_NAME`
+7. `RUN_MR_REVIEW_GATE`
+8. `ASSIGN_SPRINT`
+9. `PREPARE_RELEASE_NOTE`
+10. `MARK_TASKS_PUBLISH`
+11. `STATUS_SNAPSHOT`
 
 `VERIFY_GOVERNANCE_GATE` выполняет `Governance Watchdog Agent` перед любой операцией и блокирует выполнение при нарушении PRD/acceptance/user-confirmation правил.
 `RUN_REVIEW_GATE` выполняет `Reviewer/Judge Agent` перед коммитом:
@@ -140,6 +141,7 @@ npm run self:bootstrap
 npm run meta:verify
 npm run meta:branch
 npm run meta:task-start -- --task #12 --slug api-redirect
+npm run meta:implementation-gate -- --task #12
 npm run meta:review
 npm run meta:review-approve
 npm run meta:mr-review
@@ -155,6 +157,7 @@ npm run meta:status
 `meta:task-start` делает branch-routing preflight: сравнивает задачу с текущей веткой, показывает dirty/ahead блокеры и готовит маршрут (`stay_on_current_branch` или `create_new_branch`).
 `meta:task-start` также делает context-protection check для `AGENTS.md` (fallback: `agents.md`) между текущей и базовой веткой и требует явного подтверждения при diff.
 Именование branch task ref: использовать GitHub issue ref в формате `issue-<number>`.
+`meta:implementation-gate` блокирует старт реализации, если не выполнены условия `IN_PROGRESS + PRD sections + structured verifiability(strict/statistical/human) + branch alignment`.
 `meta:mr-review` формирует сводный pre-merge отчёт по MR/PR, `meta:mr-review-approve` фиксирует финальный PASS после подтверждения пользователя.
 `meta:status` отдаёт единый статус-срез: trackers used, current sprint, current task, current branch context, git uncommitted и summary.
 В `github` режиме локальные `tasks/*` по умолчанию считаются cache/legacy и не являются источником истины.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k0t0vich/meta-agents-template",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Template system for verification-first agentic development",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
     "meta:status": "node template/.meta-agents/scripts/sync-status.mjs",
     "meta:branch": "node template/.meta-agents/scripts/verify-branch-strategy.mjs",
     "meta:task-start": "node template/.meta-agents/scripts/task-branch-router.mjs",
+    "meta:implementation-gate": "node template/.meta-agents/scripts/verify-implementation-gate.mjs",
     "meta:verify": "node template/.meta-agents/scripts/verify-governance.mjs",
     "meta:review": "node template/.meta-agents/scripts/run-review-gate.mjs",
     "meta:review-approve": "node template/.meta-agents/scripts/run-review-gate.mjs --approve yes",

package/src/init.mjs

@@ -110,6 +110,7 @@ function buildMetaScripts(packageName) {
     "meta:status": `${base}/sync-status.mjs`,
     "meta:branch": `${base}/verify-branch-strategy.mjs`,
     "meta:task-start": `${base}/task-branch-router.mjs`,
+    "meta:implementation-gate": `${base}/verify-implementation-gate.mjs`,
     "meta:verify": `${base}/verify-governance.mjs`,
     "meta:review": `${base}/run-review-gate.mjs`,
     "meta:review-approve": `${base}/run-review-gate.mjs --approve yes`,
@@ -217,14 +218,19 @@ async function mergePackageJsonMeta({
 
 function buildAgentsLinkBlock(packageName) {
   const packageRoot = `./node_modules/${packageName}`;
+  const templateAgentsPath = `${packageRoot}/template/agents.md`;
+  const trackerTemplatePath = `${packageRoot}/template/tracker-command-template.md`;
   const lines = [
     AGENTS_LINK_BLOCK_START,
     "## Meta Agents Template (npm-linked)",
     "ОБЯЗАТЕЛЬНО: перед выполнением любой команды сначала прочитай canonical rules по ссылкам ниже.",
     "При конфликте локального текста и шаблона приоритет у canonical files из node_modules.",
     "Базовые правила шаблона:",
-    `- [Template agents.md](${packageRoot}/template/agents.md)`,
-    `- [Template tracker-command-template.md](${packageRoot}/template/tracker-command-template.md)`,
+    `- [Template agents.md](${templateAgentsPath})`,
+    `- [Template tracker-command-template.md](${trackerTemplatePath})`,
+    "Canonical files (read by path in this exact order):",
+    `1. \`${templateAgentsPath}\``,
+    `2. \`${trackerTemplatePath}\``,
     "Локальные конфиги проекта:",
     "- [.meta-agents/config/project-context.yaml](./.meta-agents/config/project-context.yaml)",
     "- [.meta-agents/config/trackers.yaml](./.meta-agents/config/trackers.yaml)",

package/template/.meta-agents/config/system.yaml

@@ -103,6 +103,7 @@ system:
         required: true
         required_before_commands:
           - CREATE_TASK
+          - VERIFY_IMPLEMENTATION_GATE
           - SET_STATUS
           - COMMIT_BY_NAME
         routing_command: "meta:task-start"
@@ -160,6 +161,7 @@ system:
       required: true
       before_commands:
         - VERIFY_GOVERNANCE_GATE
+        - VERIFY_IMPLEMENTATION_GATE
         - CREATE_TASK
         - PREPARE_TASK_BRANCH
         - SET_STATUS
@@ -225,6 +227,7 @@ system:
       - evidence_pack_complete
       - tracker_sync_complete
       - branch_routing_dialog_completed
+      - implementation_gate_passed
       - branch_routing_e2e_verified
       - agents_context_consistency_verified
       - watchdog_gate_passed

package/template/.meta-agents/scripts/sync-status.mjs

@@ -568,23 +568,29 @@ async function main() {
 
   console.log("# Status Snapshot");
   console.log("");
-  console.log("## Trackers");
+  console.log("## 1) Trackers Used");
   console.log(`- locked provider: ${report.tracker.lockedProvider}`);
   console.log(`- available providers: ${report.tracker.availableProviders.join(", ") || "unknown"}`);
   console.log(`- workflow source: ${report.tracker.workflowSource}`);
 
   console.log("");
-  console.log("## Process");
-  console.log(`- current sprint: ${report.process.currentSprint}`);
-  console.log(`- current task: ${report.process.currentTask}`);
-  console.log(`- current task ref: ${report.process.currentTaskRef}`);
-  console.log(`- branch/task alignment: ${report.process.branchTaskAlignment}`);
+  console.log("## 2) Current Sprint");
+  console.log(`- ${report.process.currentSprint}`);
 
   console.log("");
-  console.log("## Git");
+  console.log("## 3) Current Task");
+  console.log(`- task: ${report.process.currentTask}`);
+  console.log(`- task ref: ${report.process.currentTaskRef}`);
+
+  console.log("");
+  console.log("## 4) Current Branch Context");
   console.log(`- branch: ${report.git.branch}`);
   console.log(`- branch type: ${report.git.branchType}`);
   console.log(`- branch task ref: ${report.git.branchTaskRef}`);
+  console.log(`- task/branch alignment: ${report.process.branchTaskAlignment}`);
+
+  console.log("");
+  console.log("## 5) Git Uncommitted");
   console.log(`- upstream: ${report.git.upstream}`);
   console.log(`- ahead/behind: ${report.git.ahead}/${report.git.behind}`);
   console.log(`- modified_or_staged: ${report.git.modifiedOrStaged}`);
@@ -601,7 +607,7 @@ async function main() {
   }
 
   console.log("");
-  console.log("## Summary");
+  console.log("## 6) Summary");
   if (report.summary.length === 0) {
     console.log("- no additional notes");
   } else {

package/template/.meta-agents/scripts/task-branch-router.mjs

@@ -163,6 +163,7 @@ function collectGitContext() {
     branch,
     branchType: classifyBranch(branch),
     branchTaskRef: extractBranchTaskRef(branch),
+    hasCommits: hasCommits(),
     upstream: parsed.upstream || "not configured",
     ahead: parsed.ahead,
     behind: parsed.behind,
@@ -259,6 +260,10 @@ function hasRef(ref) {
   return Boolean(git(["show-ref", "--verify", ref], true));
 }
 
+function hasCommits() {
+  return Boolean(git(["rev-parse", "--verify", "HEAD"], true));
+}
+
 function hasOrigin() {
   return Boolean(git(["remote", "get-url", "origin"], true));
 }
@@ -333,6 +338,25 @@ function executePlan(plan, gitContext) {
     git(["fetch", "origin"], false);
   }
 
+  if (!gitContext.hasCommits) {
+    const baseRemote = hasRef(`refs/remotes/origin/${baseBranch}`);
+    if (baseRemote) {
+      git(["checkout", "-b", baseBranch, "--track", `origin/${baseBranch}`], false);
+    } else if (gitContext.branch !== baseBranch) {
+      git(["checkout", "-B", baseBranch], false);
+    }
+
+    if (plan.targetBranch !== baseBranch) {
+      git(["checkout", "-B", plan.targetBranch], false);
+    }
+
+    return {
+      changedBranch: plan.targetBranch !== gitContext.branch,
+      branch: plan.targetBranch,
+      message: `Repository has no commits yet. Bootstrapped branch routing and switched to '${plan.targetBranch}'.`,
+    };
+  }
+
   const baseLocal = hasRef(`refs/heads/${baseBranch}`);
   const baseRemote = hasRef(`refs/remotes/origin/${baseBranch}`);
 
@@ -411,12 +435,27 @@ function buildPlan(options, gitContext) {
     requiresDialogue.push(
       "Задача атомарная и относится к текущей feature-ветке. Подтвердите, что продолжаем работу в этой ветке.",
     );
+  } else if (!gitContext.hasCommits) {
+    requiresDialogue.push(
+      "Репозиторий без коммитов. Подтвердите bootstrap маршрута: создать базовую ветку и рабочую ветку без ручного обхода.",
+    );
   } else {
     requiresDialogue.push(
       "Задача не относится к текущей ветке. Подтвердите переключение на базовую ветку, обновление и создание новой рабочей ветки.",
     );
   }
 
+  const suggestedCommands = sameFeature
+    ? []
+    : !gitContext.hasCommits
+      ? [`git checkout -B ${baseBranch}`, `git checkout -B ${targetBranch}`]
+      : [
+          "git fetch origin",
+          `git checkout ${baseBranch}`,
+          `git pull --ff-only origin ${baseBranch}`,
+          `git checkout -b ${targetBranch}`,
+        ];
+
   return {
     requested: {
       task: options.task,
@@ -431,14 +470,7 @@ function buildPlan(options, gitContext) {
     namingWarnings,
     contextWarnings: getContextWarnings(baseBranch),
     requiresDialogue,
-    suggestedCommands: sameFeature
-      ? []
-      : [
-          "git fetch origin",
-          `git checkout ${baseBranch}`,
-          `git pull --ff-only origin ${baseBranch}`,
-          `git checkout -b ${targetBranch}`,
-        ],
+    suggestedCommands,
   };
 }
 
@@ -449,6 +481,7 @@ function printPlan(plan, applyResult) {
   console.log(`- branch: ${plan.current.branch}`);
   console.log(`- branch type: ${plan.current.branchType}`);
   console.log(`- branch task ref: ${plan.current.branchTaskRef || "not detected"}`);
+  console.log(`- repository state: ${plan.current.hasCommits ? "has commits" : "no commits yet"}`);
   console.log(`- upstream: ${plan.current.upstream}`);
   console.log(`- ahead/behind: ${plan.current.ahead}/${plan.current.behind}`);
   console.log(`- modified_or_staged: ${plan.current.modifiedOrStaged}`);

package/template/.meta-agents/scripts/tracker/github.mjs

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import process from "node:process";
 
 const STATUS_LABELS = ["TODO", "IN_PROGRESS", "REVIEW", "READY", "BLOCKED", "DONE", "PUBLISH"];
+const REQUIRED_PRD_HEADINGS = ["### Описание", "### Проверяемость", "### Что сделано"];
 const STATUS_COLORS = {
   IN_PROGRESS: "FBCA04",
   REVIEW: "5319E7",
@@ -168,6 +169,129 @@ function parseLabelsInput(value) {
     .filter(Boolean);
 }
 
+function extractSection(content, heading) {
+  const source = String(content || "");
+  if (!source || !heading) {
+    return "";
+  }
+  const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`${escapedHeading}\\s*\\n([\\s\\S]*?)(?:\\n###\\s+|$)`, "i");
+  const match = source.match(regex);
+  return (match?.[1] || "").trim();
+}
+
+function parsePrefixedValue(raw, key) {
+  const source = toNonEmptyString(raw);
+  if (!source) {
+    return "";
+  }
+  const regex = new RegExp(`${key}\\s*:\\s*([^\\n;]+)`, "i");
+  const match = source.match(regex);
+  return (match?.[1] || "").trim();
+}
+
+function buildVerifiability(payload = {}) {
+  const structured = payload.verifiability;
+  let strict = "";
+  let statistical = "";
+  let human = "";
+
+  if (structured && typeof structured === "object" && !Array.isArray(structured)) {
+    strict = pickFirstNonEmpty(structured.strict, payload.strict, payload.verificationStrict);
+    statistical = pickFirstNonEmpty(
+      structured.statistical,
+      payload.statistical,
+      payload.verificationStatistical,
+    );
+    human = pickFirstNonEmpty(structured.human, payload.human, payload.verificationHuman);
+  } else {
+    const flat = pickFirstNonEmpty(payload.verifiability, payload.verification);
+    strict = pickFirstNonEmpty(
+      payload.strict,
+      payload.verificationStrict,
+      parsePrefixedValue(flat, "strict"),
+    );
+    statistical = pickFirstNonEmpty(
+      payload.statistical,
+      payload.verificationStatistical,
+      parsePrefixedValue(flat, "statistical"),
+    );
+    human = pickFirstNonEmpty(
+      payload.human,
+      payload.verificationHuman,
+      parsePrefixedValue(flat, "human"),
+    );
+  }
+
+  return {
+    strict: strict || "schema/types/invariants defined",
+    statistical: statistical || "N/A (provide measurable threshold if metric is applicable)",
+    human: human || "manual review and acceptance by task owner",
+  };
+}
+
+function validateVerifiabilitySection(body) {
+  const section = extractSection(body, "### Проверяемость");
+  if (!section) {
+    return {
+      ok: false,
+      reasons: ["missing section '### Проверяемость'"],
+    };
+  }
+
+  const hasStrict = /(^|\n)\s*-\s*strict\s*:/i.test(section);
+  const hasStatistical = /(^|\n)\s*-\s*statistical\s*:/i.test(section);
+  const hasHuman = /(^|\n)\s*-\s*human\s*:/i.test(section);
+  const reasons = [];
+
+  if (!hasStrict) {
+    reasons.push("missing 'strict:' row in verifiability");
+  }
+  if (!hasStatistical) {
+    reasons.push("missing 'statistical:' row in verifiability");
+  }
+  if (!hasHuman) {
+    reasons.push("missing 'human:' row in verifiability");
+  }
+
+  const statisticalMatch = section.match(/(^|\n)\s*-\s*statistical\s*:\s*(.+)$/im);
+  if (statisticalMatch) {
+    const statisticalValue = toNonEmptyString(statisticalMatch[2]);
+    const hasThresholdOrNA = /(<=|>=|<|>|=|\b\d+(\.\d+)?\b|N\/A|^NA\b|not applicable)/i.test(
+      statisticalValue,
+    );
+    if (!hasThresholdOrNA) {
+      reasons.push("statistical row must include measurable threshold or explicit N/A");
+    }
+  }
+
+  return {
+    ok: reasons.length === 0,
+    reasons,
+  };
+}
+
+function validateIssueBodyForInProgress(body) {
+  const reasons = [];
+  for (const heading of REQUIRED_PRD_HEADINGS) {
+    if (!String(body || "").includes(heading)) {
+      reasons.push(`missing required PRD heading '${heading}'`);
+    }
+  }
+
+  const verifiabilityCheck = validateVerifiabilitySection(body);
+  if (!verifiabilityCheck.ok) {
+    for (const reason of verifiabilityCheck.reasons) {
+      reasons.push(reason);
+    }
+  }
+
+  return {
+    ok: reasons.length === 0,
+    reasons,
+  };
+}
+
 function labelColor(name) {
   if (STATUS_COLORS[name]) {
     return STATUS_COLORS[name];
@@ -234,10 +358,7 @@ function renderCreateTaskBody(payload, labels) {
     payload.description,
     "заполнить описание задачи",
   );
-  const verifiability = renderBulletedValue(
-    payload.verifiability || payload.verification,
-    "strict: TBD; statistical: TBD; human: TBD",
-  );
+  const verifiability = buildVerifiability(payload);
   const doneBlock = renderBulletedValue(
     payload.done,
     "[ ] Не начато",
@@ -262,7 +383,9 @@ function renderCreateTaskBody(payload, labels) {
     description,
     "",
     "### Проверяемость",
-    verifiability,
+    `- strict: ${verifiability.strict}`,
+    `- statistical: ${verifiability.statistical}`,
+    `- human: ${verifiability.human}`,
     "",
     "### Что сделано",
     doneBlock,
@@ -318,6 +441,15 @@ function resolveTaskIssue(payload) {
   return issue;
 }
 
+function getIssueDetails(issue, repo) {
+  const repoArgs = toRepoArgs(repo);
+  return readJson(
+    "gh",
+    ["issue", "view", String(issue), "--json", "number,title,body,labels,url", ...repoArgs],
+    false,
+  );
+}
+
 function getIssueLabels(issue, repo) {
   const repoArgs = toRepoArgs(repo);
   const issueData = readJson(
@@ -457,6 +589,15 @@ export async function setStatus(payload = {}) {
   }
 
   ensureGhReady();
+  if (targetStatus === "IN_PROGRESS") {
+    const issueData = getIssueDetails(issue, repo);
+    const validation = validateIssueBodyForInProgress(issueData?.body || "");
+    if (!validation.ok) {
+      throw new Error(
+        `BLOCKED: cannot set #${issue} -> IN_PROGRESS. ${validation.reasons.join("; ")}`,
+      );
+    }
+  }
   ensureLabelsExist([targetStatus], repo);
 
   const currentLabels = getIssueLabels(issue, repo);

package/template/.meta-agents/scripts/tracker-gateway.mjs

@@ -1,8 +1,11 @@
 import process from "node:process";
 import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { resolveTrackerForCommand } from "./tracker/provider-lock.mjs";
 
 const COMMAND_MAP = {
+  VERIFY_IMPLEMENTATION_GATE: "__verifyImplementationGate",
   CREATE_TASK: "createTask",
   PREPARE_TASK_BRANCH: "__prepareTaskBranch",
   RUN_MR_REVIEW_GATE: "__runMrReviewGate",
@@ -11,12 +14,37 @@ const COMMAND_MAP = {
   ASSIGN_SPRINT: "assignSprint",
 };
 
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+
+function scriptPath(fileName) {
+  return path.join(SCRIPT_DIR, fileName);
+}
+
+function runNodeScript(args) {
+  try {
+    const output = execFileSync("node", args, {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    return output.trim();
+  } catch (error) {
+    const stdout = String(error?.stdout || "").trim();
+    const stderr = String(error?.stderr || "").trim();
+    const details = [stderr, stdout].filter(Boolean).join("\n");
+    if (details) {
+      throw new Error(details);
+    }
+    throw error;
+  }
+}
+
 function printHelp() {
   console.log("TrackerGateway CLI");
   console.log("");
   console.log("Usage:");
   console.log(
-    "  npm run meta:ops -- --command CREATE_TASK|PREPARE_TASK_BRANCH|RUN_MR_REVIEW_GATE|SET_STATUS|COMMIT_BY_NAME|ASSIGN_SPRINT [--tracker github|mcp|local|custom] [--payload '{\"k\":\"v\"}']",
+    "  npm run meta:ops -- --command VERIFY_IMPLEMENTATION_GATE|CREATE_TASK|PREPARE_TASK_BRANCH|RUN_MR_REVIEW_GATE|SET_STATUS|COMMIT_BY_NAME|ASSIGN_SPRINT [--tracker github|mcp|local|custom] [--payload '{\"k\":\"v\"}']",
   );
   console.log("");
   console.log("Rules:");
@@ -27,7 +55,7 @@ function printHelp() {
 }
 
 function runTaskBranchRouter(payload) {
-  const args = [".meta-agents/scripts/task-branch-router.mjs"];
+  const args = [scriptPath("task-branch-router.mjs")];
   if (payload.task) {
     args.push("--task", String(payload.task));
   }
@@ -53,18 +81,14 @@ function runTaskBranchRouter(payload) {
     args.push("--json");
   }
 
-  const output = execFileSync("node", args, {
-    cwd: process.cwd(),
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  });
+  const output = runNodeScript(args);
   if (output.trim()) {
     console.log(output.trim());
   }
 }
 
 function runMrReviewGate(payload) {
-  const args = [".meta-agents/scripts/run-mr-review-gate.mjs"];
+  const args = [scriptPath("run-mr-review-gate.mjs")];
   if (payload.pr) {
     args.push("--pr", String(payload.pr));
   }
@@ -78,11 +102,23 @@ function runMrReviewGate(payload) {
     args.push("--json");
   }
 
-  const output = execFileSync("node", args, {
-    cwd: process.cwd(),
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  });
+  const output = runNodeScript(args);
+  if (output.trim()) {
+    console.log(output.trim());
+  }
+}
+
+function runImplementationGate(payload, trackerProvider) {
+  const args = [scriptPath("verify-implementation-gate.mjs")];
+  if (payload.task) {
+    args.push("--task", String(payload.task));
+  }
+  if (payload.json) {
+    args.push("--json");
+  }
+  args.push("--tracker", trackerProvider);
+
+  const output = runNodeScript(args);
   if (output.trim()) {
     console.log(output.trim());
   }
@@ -174,6 +210,11 @@ async function main() {
     console.log(`TrackerGateway PASS: ${options.command} via tracker '${trackerProvider}'.`);
     return;
   }
+  if (adapterMethod === "__verifyImplementationGate") {
+    runImplementationGate(payload, trackerProvider);
+    console.log(`TrackerGateway PASS: ${options.command} via tracker '${trackerProvider}'.`);
+    return;
+  }
   if (adapterMethod === "__runMrReviewGate") {
     runMrReviewGate(payload);
     console.log(`TrackerGateway PASS: ${options.command} via tracker '${trackerProvider}'.`);

package/template/.meta-agents/scripts/verify-implementation-gate.mjs

@@ -0,0 +1,373 @@
+import { execFileSync } from "node:child_process";
+import process from "node:process";
+import { resolveTrackerForCommand } from "./tracker/provider-lock.mjs";
+
+const STATUS_LABELS = ["TODO", "IN_PROGRESS", "REVIEW", "READY", "BLOCKED", "DONE", "PUBLISH"];
+const REQUIRED_PRD_HEADINGS = ["### Описание", "### Проверяемость", "### Что сделано"];
+const IMPLEMENTATION_BRANCH_TYPES = new Set(["feature", "release", "hotfix"]);
+
+function run(command, args, allowFailure = false) {
+  try {
+    return execFileSync(command, args, {
+      encoding: "utf8",
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+  } catch (error) {
+    if (allowFailure) {
+      return "";
+    }
+    const stderr = String(error?.stderr || "").trim();
+    const stdout = String(error?.stdout || "").trim();
+    throw new Error(`${command} ${args.join(" ")} failed: ${stderr || stdout || error.message}`);
+  }
+}
+
+function readJson(command, args, allowFailure = false) {
+  const raw = run(command, args, allowFailure);
+  if (!raw) {
+    return null;
+  }
+  return JSON.parse(raw);
+}
+
+function parseArgs(argv) {
+  const options = {
+    task: "",
+    tracker: "",
+    json: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--task") {
+      options.task = (argv[i + 1] || "").trim();
+      i += 1;
+      continue;
+    }
+    if (arg === "--tracker") {
+      options.tracker = (argv[i + 1] || "").trim();
+      i += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+  }
+
+  return options;
+}
+
+function parseIssueNumber(value) {
+  const source = String(value || "").trim();
+  if (!source) {
+    return "";
+  }
+
+  const direct = source.match(/^#?(\d+)$/);
+  if (direct) {
+    return direct[1];
+  }
+
+  const issueToken = source.match(/(?:^|[\/\s])issue-(\d+)(?:-|$|\s)/i);
+  if (issueToken) {
+    return issueToken[1];
+  }
+
+  const githubUrl = source.match(/\/issues\/(\d+)(?:$|[/?#])/i);
+  if (githubUrl) {
+    return githubUrl[1];
+  }
+
+  const ref = source.match(/#(\d+)/);
+  if (ref) {
+    return ref[1];
+  }
+
+  return "";
+}
+
+function classifyBranch(branch) {
+  if (/^main$/.test(branch)) {
+    return "main";
+  }
+  if (/^develop$/.test(branch)) {
+    return "develop";
+  }
+  if (/^feature\/.+/.test(branch)) {
+    return "feature";
+  }
+  if (/^release\/.+/.test(branch)) {
+    return "release";
+  }
+  if (/^hotfix\/.+/.test(branch)) {
+    return "hotfix";
+  }
+  return "unknown";
+}
+
+function extractBranchTaskRef(branch) {
+  const source = String(branch || "").trim();
+  if (!source) {
+    return "";
+  }
+  const match = source.match(/^(feature|release|hotfix)\/(.+)$/);
+  if (!match) {
+    return "";
+  }
+  const tail = match[2];
+  const taskMatch = tail.match(/^([A-Za-z][A-Za-z0-9_]*-\d+)/);
+  if (taskMatch) {
+    return taskMatch[1].toUpperCase();
+  }
+  const issueMatch = tail.match(/^(\d+)(?:-|$)/);
+  if (issueMatch) {
+    return `ISSUE-${issueMatch[1]}`;
+  }
+  return "";
+}
+
+function detectBranch() {
+  const direct = run("git", ["rev-parse", "--abbrev-ref", "HEAD"], true);
+  if (direct && direct !== "HEAD") {
+    return direct;
+  }
+  const symbolic = run("git", ["symbolic-ref", "--short", "HEAD"], true);
+  if (symbolic) {
+    return symbolic;
+  }
+  const status = run("git", ["status", "--short", "--branch"], true);
+  const header = status.split("\n")[0] || "";
+  const noCommits = header.match(/^##\s+No commits yet on\s+(.+)$/);
+  if (noCommits) {
+    return noCommits[1].trim();
+  }
+  return "unknown";
+}
+
+function extractSection(content, heading) {
+  const source = String(content || "");
+  if (!source || !heading) {
+    return "";
+  }
+  const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`${escapedHeading}\\s*\\n([\\s\\S]*?)(?:\\n###\\s+|$)`, "i");
+  const match = source.match(regex);
+  return (match?.[1] || "").trim();
+}
+
+function validateIssueBody(issueBody) {
+  const blockers = [];
+
+  for (const heading of REQUIRED_PRD_HEADINGS) {
+    if (!String(issueBody || "").includes(heading)) {
+      blockers.push(`missing required PRD heading '${heading}'`);
+    }
+  }
+
+  const verifiability = extractSection(issueBody, "### Проверяемость");
+  if (!verifiability) {
+    blockers.push("missing section '### Проверяемость'");
+    return blockers;
+  }
+
+  if (!/(^|\n)\s*-\s*strict\s*:/i.test(verifiability)) {
+    blockers.push("missing 'strict:' row in verifiability");
+  }
+  if (!/(^|\n)\s*-\s*statistical\s*:/i.test(verifiability)) {
+    blockers.push("missing 'statistical:' row in verifiability");
+  }
+  if (!/(^|\n)\s*-\s*human\s*:/i.test(verifiability)) {
+    blockers.push("missing 'human:' row in verifiability");
+  }
+
+  const statisticalMatch = verifiability.match(/(^|\n)\s*-\s*statistical\s*:\s*(.+)$/im);
+  if (statisticalMatch) {
+    const value = String(statisticalMatch[2] || "").trim();
+    const hasThresholdOrNA = /(<=|>=|<|>|=|\b\d+(\.\d+)?\b|N\/A|^NA\b|not applicable)/i.test(value);
+    if (!hasThresholdOrNA) {
+      blockers.push("statistical row must include measurable threshold or explicit N/A");
+    }
+  }
+
+  return blockers;
+}
+
+function issueStatusFromLabels(labels) {
+  for (const label of labels || []) {
+    const name = String(label?.name || "").toUpperCase();
+    if (STATUS_LABELS.includes(name)) {
+      return name;
+    }
+  }
+  return "";
+}
+
+function ensureGhReady() {
+  run("gh", ["--version"], false);
+  const auth = run("gh", ["auth", "status"], true);
+  if (!auth) {
+    throw new Error("gh is not authenticated. Run 'gh auth login' first.");
+  }
+}
+
+function buildNextSteps({ issueNumber, branchType, branchTaskRef }) {
+  const steps = [];
+  if (!issueNumber) {
+    steps.push(
+      "Create a task first: npm run meta:ops -- --command CREATE_TASK --payload '{\"title\":\"<short-name>\",\"type\":\"task\"}'",
+    );
+    return steps;
+  }
+  steps.push(
+    `Ensure task is IN_PROGRESS: npm run meta:ops -- --command SET_STATUS --payload '{\"task\":\"#${issueNumber}\",\"status\":\"IN_PROGRESS\"}'`,
+  );
+  steps.push(
+    `Run branch preflight: npm run meta:task-start -- --task \"#${issueNumber}\" --slug <slug> --kind feature`,
+  );
+  if (!IMPLEMENTATION_BRANCH_TYPES.has(branchType) || branchTaskRef !== `ISSUE-${issueNumber}`) {
+    steps.push(
+      `Switch to aligned working branch: feature/issue-${issueNumber}-<slug>`,
+    );
+  }
+  steps.push(
+    `Re-check gate: npm run meta:implementation-gate -- --task \"#${issueNumber}\"`,
+  );
+  return steps;
+}
+
+function printHuman(report) {
+  console.log("# Implementation Gate");
+  console.log("");
+  console.log("## Inputs");
+  console.log(`- tracker: ${report.tracker}`);
+  console.log(`- task: ${report.task || "not provided"}`);
+  console.log(`- branch: ${report.branch}`);
+  console.log(`- branch type: ${report.branchType}`);
+  console.log(`- branch task ref: ${report.branchTaskRef || "not detected"}`);
+
+  console.log("");
+  console.log("## Checks");
+  console.log(`- issue: ${report.issue.number ? `#${report.issue.number}` : "not detected"}`);
+  console.log(`- issue status: ${report.issue.status || "not detected"}`);
+  console.log(`- prd/verifiability: ${report.prdOk ? "PASS" : "FAIL"}`);
+  console.log(`- branch alignment: ${report.branchAligned ? "PASS" : "FAIL"}`);
+
+  console.log("");
+  console.log("## Decision");
+  if (report.blockers.length === 0) {
+    console.log("- PASS");
+    return;
+  }
+  console.log("- BLOCKED");
+  for (const blocker of report.blockers) {
+    console.log(`- ${blocker}`);
+  }
+
+  console.log("");
+  console.log("## Next Steps");
+  for (const step of report.nextSteps) {
+    console.log(`- ${step}`);
+  }
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const tracker = resolveTrackerForCommand({
+    requestedTracker: options.tracker,
+    cwd: process.cwd(),
+  });
+
+  if (tracker !== "github") {
+    throw new Error(
+      `Implementation gate currently supports github tracker only. Locked tracker: '${tracker}'.`,
+    );
+  }
+
+  ensureGhReady();
+
+  const issueNumber = parseIssueNumber(options.task);
+  const branch = detectBranch();
+  const branchType = classifyBranch(branch);
+  const branchTaskRef = extractBranchTaskRef(branch);
+  const blockers = [];
+  let issue = { number: "", title: "", status: "", url: "" };
+  let prdOk = false;
+
+  if (!issueNumber) {
+    blockers.push("missing issue ref. Provide --task '#<number>'");
+  } else {
+    const issueData = readJson("gh", [
+      "issue",
+      "view",
+      issueNumber,
+      "--json",
+      "number,title,body,labels,url",
+    ]);
+    issue = {
+      number: String(issueData?.number || issueNumber),
+      title: issueData?.title || "",
+      status: issueStatusFromLabels(issueData?.labels || []),
+      url: issueData?.url || "",
+    };
+
+    if (issue.status !== "IN_PROGRESS") {
+      blockers.push(`issue #${issue.number} status must be IN_PROGRESS, got '${issue.status || "none"}'`);
+    }
+
+    const prdBlockers = validateIssueBody(issueData?.body || "");
+    if (prdBlockers.length > 0) {
+      for (const blocker of prdBlockers) {
+        blockers.push(`issue #${issue.number}: ${blocker}`);
+      }
+    } else {
+      prdOk = true;
+    }
+
+    if (!IMPLEMENTATION_BRANCH_TYPES.has(branchType)) {
+      blockers.push(
+        `branch type must be feature/release/hotfix for implementation, got '${branchType}'`,
+      );
+    }
+    if (branchTaskRef && branchTaskRef !== `ISSUE-${issue.number}`) {
+      blockers.push(
+        `branch task ref '${branchTaskRef}' is not aligned with issue '#${issue.number}'`,
+      );
+    }
+    if (!branchTaskRef) {
+      blockers.push("branch task ref not detected; run PREPARE_TASK_BRANCH first");
+    }
+  }
+
+  const nextSteps = buildNextSteps({ issueNumber, branchType, branchTaskRef });
+  const report = {
+    tracker,
+    task: options.task,
+    branch,
+    branchType,
+    branchTaskRef,
+    issue,
+    prdOk,
+    branchAligned: Boolean(issueNumber) && branchTaskRef === `ISSUE-${issueNumber}` && IMPLEMENTATION_BRANCH_TYPES.has(branchType),
+    blockers,
+    nextSteps,
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    printHuman(report);
+  }
+
+  if (blockers.length > 0) {
+    process.exit(1);
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`implementation-gate FAIL: ${error.message}`);
+  process.exit(1);
+}

package/template/README.md

@@ -50,6 +50,7 @@
 npm run meta:verify
 npm run meta:branch
 npm run meta:task-start -- --task #12 --slug api-redirect
+npm run meta:implementation-gate -- --task #12
 npm run meta:review
 npm run meta:review-approve
 npm run meta:mr-review
@@ -66,6 +67,7 @@ npm run meta:status
 `meta:task-start` делает branch-routing preflight: сравнивает задачу с текущей веткой, показывает dirty/ahead блокеры и готовит маршрут (`stay_on_current_branch` или `create_new_branch`).
 `meta:task-start` также делает context-protection check для `AGENTS.md` (fallback: `agents.md`) между текущей и базовой веткой и требует явного подтверждения при diff.
 Именование branch task ref: использовать GitHub issue ref в формате `issue-<number>`.
+`meta:implementation-gate` блокирует старт реализации, если не выполнены условия `IN_PROGRESS + PRD sections + structured verifiability(strict/statistical/human) + branch alignment`.
 `meta:mr-review` формирует сводный pre-merge отчёт по MR/PR, `meta:mr-review-approve` фиксирует финальный PASS после подтверждения пользователя.
 
 `meta:status` выдаёт сводный статус:

package/template/agents.md

@@ -123,13 +123,14 @@ Name: <agent role>
 1. `CREATE_TASK`
 2. `PREPARE_TASK_BRANCH`
 3. `SET_STATUS`
-4. `RUN_REVIEW_GATE`
-5. `COMMIT_BY_NAME`
-6. `RUN_MR_REVIEW_GATE`
-7. `ASSIGN_SPRINT`
-8. `PREPARE_RELEASE_NOTE`
-9. `MARK_TASKS_PUBLISH`
-10. `STATUS_SNAPSHOT`
+4. `VERIFY_IMPLEMENTATION_GATE`
+5. `RUN_REVIEW_GATE`
+6. `COMMIT_BY_NAME`
+7. `RUN_MR_REVIEW_GATE`
+8. `ASSIGN_SPRINT`
+9. `PREPARE_RELEASE_NOTE`
+10. `MARK_TASKS_PUBLISH`
+11. `STATUS_SNAPSHOT`
 
 ## 10) Коммиты и закрытие задач: только по подтверждению пользователя
 Запрещено выполнять автоматически:
@@ -148,6 +149,7 @@ Name: <agent role>
 - без подтверждения пользователя максимум допустимого статуса: `REVIEW`.
 - `SET_STATUS -> READY` разрешён только после `RUN_REVIEW_GATE: PASS_CONFIRMED`.
 - для задач реализации по умолчанию используется отдельная ветка `feature/*`; прямой рабочий поток на `develop`/`main` не допускается.
+- перед началом реализации после `SET_STATUS -> IN_PROGRESS` обязателен `VERIFY_IMPLEMENTATION_GATE`.
 - сообщение коммита обязано начинаться с ссылки на задачу и summary в формате `#issue-number <summary>`.
 - `READY` означает: коммит сделан и отправлен (`push`) в `feature/*`, `release/*` или `hotfix/*` с открытым PR по правилам ветвления.
 - `DONE` означает: изменения интегрированы в `main`; для `release/*` и `hotfix/*` подтверждён back-merge в `develop`.
@@ -188,20 +190,21 @@ Name: <agent role>
 8. Если был коммит, есть явное подтверждение пользователя на коммит.
 9. Если задача закрыта в `DONE`, есть явное подтверждение пользователя на закрытие.
 10. Перед каждой командой пройден `VERIFY_GOVERNANCE_GATE` от `Governance Watchdog Agent`.
-11. Перед коммитом пройден `RUN_REVIEW_GATE` от `Reviewer/Judge Agent`.
-12. Есть явное подтверждение пользователя на прохождение review (`Review Approved: yes`).
-13. Перед merge пройден `RUN_MR_REVIEW_GATE` от `MR Review Agent`.
-14. Есть явное подтверждение пользователя на MR review (`MR Review Approved: yes`).
-15. До review gate задача переведена в статус `REVIEW`.
-16. Статус `READY` выставлен только после `RUN_REVIEW_GATE: PASS_CONFIRMED`.
-17. Для статуса `READY` подтверждены `commit + push` в `feature/*|release/*|hotfix/*` и открытый PR в целевую ветку (`develop` или `main`).
-18. Для merge подтверждён `RUN_MR_REVIEW_GATE: PASS_CONFIRMED`.
-19. Для статуса `DONE` подтверждена интеграция в `main`; для `release/*` и `hotfix/*` подтверждён back-merge в `develop`.
-20. Для статуса `PUBLISH` подтверждена публикация в последней версии.
-21. Для релиза обновлён публичный `CHANGELOG.md`.
-22. Коммит следует формату `#issue-number <summary>` (issue ref в начале сообщения).
-23. Для branch routing собран e2e evidence по двум сценариям: `same feature` и `different feature`.
-24. Перед `--apply` подтверждена консистентность контекста `AGENTS.md` (fallback: `agents.md`) или явно подтверждён осознанный switch при diff.
+11. Перед началом реализации пройден `VERIFY_IMPLEMENTATION_GATE` (issue `IN_PROGRESS` + structured verifiability + branch alignment).
+12. Перед коммитом пройден `RUN_REVIEW_GATE` от `Reviewer/Judge Agent`.
+13. Есть явное подтверждение пользователя на прохождение review (`Review Approved: yes`).
+14. Перед merge пройден `RUN_MR_REVIEW_GATE` от `MR Review Agent`.
+15. Есть явное подтверждение пользователя на MR review (`MR Review Approved: yes`).
+16. До review gate задача переведена в статус `REVIEW`.
+17. Статус `READY` выставлен только после `RUN_REVIEW_GATE: PASS_CONFIRMED`.
+18. Для статуса `READY` подтверждены `commit + push` в `feature/*|release/*|hotfix/*` и открытый PR в целевую ветку (`develop` или `main`).
+19. Для merge подтверждён `RUN_MR_REVIEW_GATE: PASS_CONFIRMED`.
+20. Для статуса `DONE` подтверждена интеграция в `main`; для `release/*` и `hotfix/*` подтверждён back-merge в `develop`.
+21. Для статуса `PUBLISH` подтверждена публикация в последней версии.
+22. Для релиза обновлён публичный `CHANGELOG.md`.
+23. Коммит следует формату `#issue-number <summary>` (issue ref в начале сообщения).
+24. Для branch routing собран e2e evidence по двум сценариям: `same feature` и `different feature`.
+25. Перед `--apply` подтверждена консистентность контекста `AGENTS.md` (fallback: `agents.md`) или явно подтверждён осознанный switch при diff.
 
 Если хотя бы один критерий не выполнен, задача не принимается.
 

package/template/package.json

@@ -6,6 +6,7 @@
     "meta:status": "node ./node_modules/@k0t0vich/meta-agents-template/template/.meta-agents/scripts/sync-status.mjs",
     "meta:branch": "node ./node_modules/@k0t0vich/meta-agents-template/template/.meta-agents/scripts/verify-branch-strategy.mjs",
     "meta:task-start": "node ./node_modules/@k0t0vich/meta-agents-template/template/.meta-agents/scripts/task-branch-router.mjs",
+    "meta:implementation-gate": "node ./node_modules/@k0t0vich/meta-agents-template/template/.meta-agents/scripts/verify-implementation-gate.mjs",
     "meta:verify": "node ./node_modules/@k0t0vich/meta-agents-template/template/.meta-agents/scripts/verify-governance.mjs",
     "meta:review": "node ./node_modules/@k0t0vich/meta-agents-template/template/.meta-agents/scripts/run-review-gate.mjs",
     "meta:review-approve": "node ./node_modules/@k0t0vich/meta-agents-template/template/.meta-agents/scripts/run-review-gate.mjs --approve yes",

package/template/tracker-command-template.md

@@ -64,6 +64,7 @@ result PASS
 - merge разрешён только после `RUN_MR_REVIEW_GATE: PASS_CONFIRMED`;
 - для задач реализации по умолчанию используется отдельная ветка `feature/*`; прямой поток на `develop`/`main` запрещён;
 - перед началом реализации обязателен `PREPARE_TASK_BRANCH` (веточный preflight и user dialogue);
+- после `SET_STATUS -> IN_PROGRESS` и перед началом реализации обязателен `VERIFY_IMPLEMENTATION_GATE`;
 - branch naming policy: использовать только GitHub issue ref в формате `issue-<number>`;
 - если задача атомарная и относится к текущей feature-ветке, допускается выполнение в текущей ветке после явного подтверждения пользователя;
 - если задача не относится к текущей ветке, требуется: проверить dirty/ahead, согласовать действие с пользователем, перейти на `develop` (или `main` для hotfix), обновить и создать новую ветку;
@@ -153,7 +154,7 @@ repo your-org/your-repo,
 short name "API редирект офферов",
 owner "Engineering Agent",
 description "Добавить API редиректа на офферы",
-verifiability "strict: schema+contracts; statistical: p95 latency < 200ms",
+verifiability "strict: schema+contracts; statistical: p95 latency < 200ms; human: reviewer approval required",
 sprint "SPRINT-3"
 ```
 
@@ -190,6 +191,23 @@ command "npm run meta:task-start -- --task #12 --slug api-redirect",
 user dialogue "confirm branch context + dirty/ahead handling + AGENTS.md context warning + switch decision"
 ```
 
+### VERIFY_IMPLEMENTATION_GATE (обязателен после IN_PROGRESS и до реализации)
+```text
+[Agent Auto-Select]
+Selected: Governance Watchdog Agent
+Reason: Нужен жесткий pre-implementation gate с проверкой task статуса, PRD структуры и branch alignment.
+
+[Task Agent]
+Name: Governance Watchdog Agent
+
+Governance Watchdog Agent: verify implementation gate,
+tracker __DEFAULT_TRACKER__,
+task #12,
+command "npm run meta:implementation-gate -- --task #12",
+required checks "issue_status_in_progress, prd_sections_complete, verifiability(strict/statistical/human), branch_alignment",
+result PASS
+```
+
 ### SET_STATUS -> REVIEW (обязателен перед review gate)
 ```text
 [Agent Auto-Select]
@@ -422,18 +440,19 @@ reason "вошло в релиз v0.1.2"
 2. `CREATE_TASK`.
 3. `PREPARE_TASK_BRANCH`.
 4. `SET_STATUS -> IN_PROGRESS`.
-5. Реализация + evidence.
-6. `SET_STATUS -> REVIEW`.
-7. `RUN_REVIEW_GATE` (получить report + `PASS_CANDIDATE`/`FAIL`).
-8. Пользователь подтверждает review (`Review Approved: yes`).
-9. `RUN_REVIEW_GATE` -> `PASS_CONFIRMED`.
-10. `COMMIT_BY_NAME` только после review PASS_CONFIRMED и отдельного подтверждения пользователя на коммит.
-11. Push + open PR в целевую ветку по Git Flow Lite.
-12. `RUN_MR_REVIEW_GATE` (получить report + `PASS_CANDIDATE`/`FAIL`).
-13. Пользователь подтверждает MR review (`MR Review Approved: yes`).
-14. `RUN_MR_REVIEW_GATE` -> `PASS_CONFIRMED`.
-15. Merge PR по Git Flow Lite.
-16. `SET_STATUS -> READY`.
-17. `SET_STATUS -> DONE` только после подтверждения пользователя.
-18. `PREPARE_RELEASE_NOTE` (какие задачи вошли в релиз).
-19. Для релизных задач после публикации: `MARK_TASKS_PUBLISH` (`SET_STATUS -> PUBLISH` для всех вошедших задач).
+5. `VERIFY_IMPLEMENTATION_GATE`.
+6. Реализация + evidence.
+7. `SET_STATUS -> REVIEW`.
+8. `RUN_REVIEW_GATE` (получить report + `PASS_CANDIDATE`/`FAIL`).
+9. Пользователь подтверждает review (`Review Approved: yes`).
+10. `RUN_REVIEW_GATE` -> `PASS_CONFIRMED`.
+11. `COMMIT_BY_NAME` только после review PASS_CONFIRMED и отдельного подтверждения пользователя на коммит.
+12. Push + open PR в целевую ветку по Git Flow Lite.
+13. `RUN_MR_REVIEW_GATE` (получить report + `PASS_CANDIDATE`/`FAIL`).
+14. Пользователь подтверждает MR review (`MR Review Approved: yes`).
+15. `RUN_MR_REVIEW_GATE` -> `PASS_CONFIRMED`.
+16. Merge PR по Git Flow Lite.
+17. `SET_STATUS -> READY`.
+18. `SET_STATUS -> DONE` только после подтверждения пользователя.
+19. `PREPARE_RELEASE_NOTE` (какие задачи вошли в релиз).
+20. Для релизных задач после публикации: `MARK_TASKS_PUBLISH` (`SET_STATUS -> PUBLISH` для всех вошедших задач).