workflow-ai 1.0.57 → 1.0.59

package/README.md

@@ -26,8 +26,10 @@ workflow run
 |---------|-------------|
 | `workflow init [path] [--force]` | Initialize `.workflow/` directory with kanban board structure |
 | `workflow run [options]` | Execute the AI pipeline |
-| `workflow update [path]` | Update global dir and recreate junctions/hardlinks |
+| `workflow update [path]` | Update global dir and recreate junctions |
 | `workflow eject <skill> [path]` | Eject a skill (copy from global to project) |
+| `workflow eject-scripts [path]` | Eject scripts (copy from global to project) |
+| `workflow eject-configs [path]` | Eject configs (copy from global to project) |
 | `workflow list [path]` | List skills with status (shared/ejected/project-only) |
 | `workflow help` | Show help |
 | `workflow version` | Show version |
@@ -46,10 +48,7 @@ The `workflow init` command creates the `.workflow/` directory structure:
 
 ```
 .workflow/
-├── config/
-│   ├── config.yaml               # Workflow configuration
-│   ├── pipeline.yaml             # Pipeline stages and agents
-│   └── ticket-movement-rules.yaml
+├── config/                       # → junction to ~/.workflow/configs/ (eject to customize)
 ├── plans/
 │   ├── current/                  # Current development plans
 │   ├── templates/                # Plan templates with triggers (recurring plans)
@@ -66,8 +65,8 @@ The `workflow init` command creates the `.workflow/` directory structure:
 ├── metrics/                      # Performance metrics
 ├── templates/                    # Ticket/plan/report templates
 └── src/
-    ├── skills/                   # Skill instructions (symlinks to global)
-    └── scripts/                  # Automation scripts (hardlinks to global)
+    ├── skills/                   # Skill instructions (junctions to global, per-skill)
+    └── scripts/                  # Automation scripts (junction to global)
 ```
 
 ## Pipeline
@@ -119,10 +118,22 @@ Built-in skills for different task types:
 | `execute-task` | Task execution |
 | `review-result` | Result review against DoD |
 
-Skills are stored globally in `~/.workflow/skills/` and symlinked into projects.
+Skills are stored globally in `~/.workflow/skills/` and linked into projects via junctions.
 
 Use `workflow eject <skill>` to copy a skill into the project for customization.
 
+## Scripts
+
+Scripts are stored globally in `~/.workflow/scripts/` and linked as a single junction into `.workflow/src/scripts/`.
+
+Use `workflow eject-scripts` to copy scripts into the project for customization.
+
+## Configs
+
+Configs are stored globally in `~/.workflow/configs/` and linked as a single junction into `.workflow/config/`.
+
+Use `workflow eject-configs` to copy configs into the project for customization.
+
 ## Plan Templates
 
 Plan templates allow recurring plans to be created automatically. Templates live in `.workflow/plans/templates/` and contain trigger conditions in their frontmatter.
@@ -186,7 +197,7 @@ workflow-ai/
 │   ├── runner.mjs           # Core pipeline orchestrator
 │   ├── init.mjs             # Project initialization
 │   ├── global-dir.mjs       # Global ~/.workflow/ management
-│   ├── junction-manager.mjs # Symlink/hardlink management
+│   ├── junction-manager.mjs # Junction/symlink management
 │   ├── wf-loader.mjs        # Config loader
 │   ├── lib/                 # Utility libraries
 │   └── tests/               # Test suite

package/agent-templates/CLAUDE.md.tpl

@@ -21,6 +21,14 @@
 | Выбор следующей задачи | `node .workflow/src/scripts/pick-next-task.js` |
 | Перемещение готовых в ready | `node .workflow/src/scripts/move-to-ready.js` |
 
+### Кастомизация (eject)
+
+| Действие | Команда |
+|----------|---------|
+| Eject скила | `workflow eject <skill-name>` |
+| Eject скриптов | `workflow eject-scripts` |
+| Eject конфигов | `workflow eject-configs` |
+
 ## Workflow
 
 1. **Планирование**: Создай план в `.workflow/plans/current/`

package/agent-templates/QWEN.md.tpl

@@ -21,6 +21,14 @@
 | Выбор следующей задачи | `node .workflow/src/scripts/pick-next-task.js` |
 | Перемещение готовых в ready | `node .workflow/src/scripts/move-to-ready.js` |
 
+### Кастомизация (eject)
+
+| Действие | Команда |
+|----------|---------|
+| Eject скила | `workflow eject <skill-name>` |
+| Eject скриптов | `workflow eject-scripts` |
+| Eject конфигов | `workflow eject-configs` |
+
 ## Workflow
 
 1. **Планирование**: Создай план в `.workflow/plans/current/`

package/agent-templates/kilocodemodes.tpl

@@ -0,0 +1,13 @@
+customModes:
+  - slug: manual-testing
+    name: manual-testing
+    roleDefinition: QA-инженер (тестировщик). Находит дефекты, проверяет качество реализации через браузер и desktop-инструменты. Составляет тест-планы и тест-кейсы, выполняет smoke/regression/exploratory/acceptance тестирование, фиксирует баги с evidence. НЕ пишет автотесты в коде, НЕ исправляет баги, НЕ нагружает систему.
+    whenToUse: Тикеты QA-* или с тегом тестирования. Запросы на smoke/regression/exploratory/acceptance тестирование. Необходимость проверки через реальный UI (браузер/desktop). Составление тест-планов и тест-кейсов. Баг-репорты.
+    groups:
+      - read
+      - edit
+      - browser
+      - command
+      - mcp
+    source: project
+    customInstructions: Используй скил manual-testing.

package/configs/pipeline.yaml

@@ -552,6 +552,8 @@ pipeline:
   protected_files:
     - ".workflow/plans/**"       # Планы — только для чтения
     - ".workflow/config/**"      # Конфигурация
+    - pattern: ".workflow/tickets/**"
+      mode: structure            # Защита только структуры (создание/удаление файлов)
 
   # ===========================================================================
   # Доверенные агенты (trusted_agents)
@@ -561,6 +563,17 @@ pipeline:
   # ===========================================================================
   trusted_agents:
     - "script-check-templates"   # Создаёт планы в plans/current/
+    - "script-*"                  # Все скрипты
+
+  # ===========================================================================
+  # Доверенные стейджи (trusted_stages)
+  # ===========================================================================
+  # Стейджи, которые могут создавать/удалять файлы в protected_files.
+  # Например, decompose-plan и decompose-gaps создают тикеты.
+  # ===========================================================================
+  trusted_stages:
+    - "decompose-plan"
+    - "decompose-gaps"
 
   # ===========================================================================
   # Настройки выполнения (execution)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workflow-ai",
-  "version": "1.0.57",
+  "version": "1.0.59",
   "description": "AI Agent Workflow Coordinator — kanban-based pipeline for AI coding agents",
   "type": "module",
   "bin": {

package/src/cli.mjs

@@ -6,7 +6,7 @@ import { readFileSync } from 'node:fs';
 import { join, dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getGlobalDir, refreshGlobalDir, ensureGlobalDir } from './global-dir.mjs';
-import { createSkillJunctions, createScriptHardlinks, ejectSkill, listSkillsWithStatus } from './junction-manager.mjs';
+import { createSkillJunctions, createScriptJunction, createConfigJunction, ejectSkill, ejectScripts, ejectConfigs, listSkillsWithStatus } from './junction-manager.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgPath = join(__dirname, '..', 'package.json');
@@ -14,13 +14,15 @@ const pkgPath = join(__dirname, '..', 'package.json');
 const HELP_TEXT = `workflow-ai v1.0.0
 
 Usage:
-  workflow init [path] [--force]   Initialize .workflow/ in target directory
-  workflow run [options]           Run the AI pipeline
-  workflow update [path]           Update global dir and recreate junctions/hardlinks
-  workflow eject <skill> [path]    Eject a skill (copy from global to project)
-  workflow list [path]             List skills with status (shared/ejected/project-only)
-  workflow help                    Show this help
-  workflow version                 Show version
+  workflow init [path] [--force]     Initialize .workflow/ in target directory
+  workflow run [options]             Run the AI pipeline
+  workflow update [path]               Update global dir and recreate junctions
+  workflow eject <skill> [path]      Eject a skill (copy from global to project)
+  workflow eject-scripts [path]      Eject scripts (copy from global to project)
+  workflow eject-configs [path]      Eject configs (copy from global to project)
+  workflow list [path]               List skills with status (shared/ejected/project-only)
+  workflow help                      Show this help
+  workflow version                   Show version
 
 Run options:
   --plan <plan>      Plan ID to execute
@@ -94,7 +96,6 @@ function runUpdate(args) {
   const workflowRoot = getWorkflowRoot(projectRoot);
   const packageRoot = getPackageRoot();
   const globalDir = getGlobalDir();
-
   refreshGlobalDir(packageRoot);
   console.log('✅ Global dir updated (~/.workflow/)');
 
@@ -103,8 +104,12 @@ function runUpdate(args) {
   console.log('✅ Skill junctions recreated');
 
   const scriptsDir = join(workflowRoot, 'src', 'scripts');
-  createScriptHardlinks(globalDir, scriptsDir);
-  console.log('✅ Script hardlinks recreated');
+  createScriptJunction(globalDir, scriptsDir);
+  console.log('✅ Script junction recreated');
+
+  const configDir = join(workflowRoot, 'config');
+  createConfigJunction(globalDir, configDir);
+  console.log('✅ Config junction recreated');
 }
 
 function runEject(args) {
@@ -122,6 +127,26 @@ function runEject(args) {
   console.log(`✅ Skill "${skillName}" ejected (copied to project)`);
 }
 
+function runEjectScripts(args) {
+  const projectRoot = resolve(args._[0] || process.cwd());
+  const workflowRoot = getWorkflowRoot(projectRoot);
+  const globalDir = getGlobalDir();
+  const scriptsDir = join(workflowRoot, 'src', 'scripts');
+
+  ejectScripts(globalDir, scriptsDir);
+  console.log('✅ Scripts ejected (copied to project)');
+}
+
+function runEjectConfigs(args) {
+  const projectRoot = resolve(args._[0] || process.cwd());
+  const workflowRoot = getWorkflowRoot(projectRoot);
+  const globalDir = getGlobalDir();
+  const configDir = join(workflowRoot, 'config');
+
+  ejectConfigs(globalDir, configDir);
+  console.log('✅ Configs ejected (copied to project)');
+}
+
 function runList(args) {
   const projectRoot = resolve(args._[0] || process.cwd());
   const workflowRoot = getWorkflowRoot(projectRoot);
@@ -184,6 +209,12 @@ export function run(argv) {
     case 'eject':
       runEject(args);
       break;
+    case 'eject-scripts':
+      runEjectScripts(args);
+      break;
+    case 'eject-configs':
+      runEjectConfigs(args);
+      break;
     case 'list':
       runList(args);
       break;

package/src/global-dir.mjs

@@ -35,12 +35,14 @@ function copyDirectory(src, dest) {
   cpSync(src, dest, { recursive: true });
 }
 
-function copySkillsAndScripts(packageRoot) {
+function copySkillsScriptsAndConfigs(packageRoot) {
   const globalDir = getGlobalDir();
   const srcSkills = join(packageRoot, 'src', 'skills');
   const srcScripts = join(packageRoot, 'src', 'scripts');
+  const srcConfigs = join(packageRoot, 'configs');
   const destSkills = join(globalDir, 'skills');
   const destScripts = join(globalDir, 'scripts');
+  const destConfigs = join(globalDir, 'configs');
 
   if (existsSync(srcSkills)) {
     copyDirectory(srcSkills, destSkills);
@@ -48,6 +50,9 @@ function copySkillsAndScripts(packageRoot) {
   if (existsSync(srcScripts)) {
     copyDirectory(srcScripts, destScripts);
   }
+  if (existsSync(srcConfigs)) {
+    copyDirectory(srcConfigs, destConfigs);
+  }
 }
 
 export function isGlobalDirStale(packageRoot) {
@@ -67,7 +72,7 @@ export function ensureGlobalDir(packageRoot) {
   const globalDir = getGlobalDir();
   if (!existsSync(globalDir)) {
     mkdirSync(globalDir, { recursive: true });
-    copySkillsAndScripts(packageRoot);
+    copySkillsScriptsAndConfigs(packageRoot);
     const version = getPackageVersion(packageRoot);
     writeFileSync(join(globalDir, '.version'), version);
     return;
@@ -75,7 +80,7 @@ export function ensureGlobalDir(packageRoot) {
   if (isGlobalDirStale(packageRoot)) {
     const version = getPackageVersion(packageRoot);
     writeFileSync(join(globalDir, '.version'), version);
-    copySkillsAndScripts(packageRoot);
+    copySkillsScriptsAndConfigs(packageRoot);
   }
 }
 
@@ -86,5 +91,5 @@ export function refreshGlobalDir(packageRoot) {
   }
   const version = getPackageVersion(packageRoot);
   writeFileSync(join(globalDir, '.version'), version);
-  copySkillsAndScripts(packageRoot);
+  copySkillsScriptsAndConfigs(packageRoot);
 }

package/src/init.mjs

@@ -3,7 +3,7 @@ import { join, resolve, dirname, basename } from 'node:path';
 import { execSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { getGlobalDir, ensureGlobalDir } from './global-dir.mjs';
-import { createSkillJunctions, createScriptHardlinks } from './junction-manager.mjs';
+import { createSkillJunctions, createScriptJunction, createConfigJunction } from './junction-manager.mjs';
 
 /**
  * Возвращает абсолютный путь к корню npm-пакета через import.meta.url.
@@ -230,6 +230,21 @@ function generateQwenMd(workflowRoot, projectRoot, packageRoot) {
   writeFileSync(destPath, content, 'utf-8');
 }
 
+/**
+ * Генерирует .kilocodemodes из шаблона agent-templates/kilocodemodes.tpl.
+ *
+ * @param {string} projectRoot - Путь к корню проекта
+ * @param {string} packageRoot - Путь к корню пакета
+ */
+function generateKilocodemodes(projectRoot, packageRoot) {
+  const templatePath = join(packageRoot, 'agent-templates', 'kilocodemodes.tpl');
+  const destPath = join(projectRoot, '.kilocodemodes');
+
+  if (existsSync(templatePath)) {
+    copyFileSync(templatePath, destPath);
+  }
+}
+
 /**
  * Обновляет .gitignore, добавляя указанные строки.
  *
@@ -248,6 +263,7 @@ function updateGitignore(projectRoot) {
     'QWEN.md',
     'CLAUDE.md',
     '.kilocode/',
+    '.kilocodemodes',
   ];
   
   let currentContent = '';
@@ -355,7 +371,6 @@ export function initProject(targetPath = process.cwd(), options = {}) {
     'reports',
     'logs',
     'templates',
-    'config',
     'src/skills'
   ];
   
@@ -371,10 +386,10 @@ export function initProject(targetPath = process.cwd(), options = {}) {
   createSkillJunctions(globalDir, srcSkillsDest);
   result.steps.push('Created skill junctions from global dir → .workflow/src/skills/');
 
-  // Step 3: Create script hardlinks
+  // Step 3: Create script junction
   const srcScriptsDest = join(workflowRoot, 'src', 'scripts');
-  createScriptHardlinks(globalDir, srcScriptsDest);
-  result.steps.push('Created script hardlinks from global dir → .workflow/src/scripts/');
+  createScriptJunction(globalDir, srcScriptsDest);
+  result.steps.push('Created script junction from global dir → .workflow/src/scripts/');
 
   // Step 5: Copy templates (3 templates)
   const templatesSrc = join(packageRoot, 'templates');
@@ -391,35 +406,10 @@ export function initProject(targetPath = process.cwd(), options = {}) {
   }
   result.steps.push('Copied 3 templates → .workflow/templates/');
   
-  // Step 6: Generate config files
+  // Step 6: Create config junction
   const configDest = join(workflowRoot, 'config');
-  ensureDir(configDest);
-  
-  // config.yaml — only if not exists (fresh only)
-  const configYamlDest = join(configDest, 'config.yaml');
-  if (!existsSync(configYamlDest) || force) {
-    const configYamlSrc = join(packageRoot, 'configs', 'config.yaml');
-    if (existsSync(configYamlSrc)) {
-      copyFile(configYamlSrc, configYamlDest);
-      result.steps.push('Generated config.yaml (fresh)');
-    }
-  } else {
-    result.warnings.push('config.yaml already exists, skipped (use --force to overwrite)');
-  }
-  
-  // pipeline.yaml — always
-  const pipelineSrc = join(packageRoot, 'configs', 'pipeline.yaml');
-  if (existsSync(pipelineSrc)) {
-    copyFile(pipelineSrc, join(configDest, 'pipeline.yaml'));
-    result.steps.push('Generated pipeline.yaml (overwritten)');
-  }
-
-  // ticket-movement-rules.yaml — always
-  const movementRulesSrc = join(packageRoot, 'configs', 'ticket-movement-rules.yaml');
-  if (existsSync(movementRulesSrc)) {
-    copyFile(movementRulesSrc, join(configDest, 'ticket-movement-rules.yaml'));
-    result.steps.push('Generated ticket-movement-rules.yaml (overwritten)');
-  }
+  createConfigJunction(globalDir, configDest);
+  result.steps.push('Created config junction from global dir → .workflow/config/');
 
   // Step 7: Create .kilocode symlinks
   const symlinkResult = createKilocodeSymlinks(projectRoot, force);
@@ -432,10 +422,11 @@ export function initProject(targetPath = process.cwd(), options = {}) {
     result.errors.push(symlinkResult.warning || 'Failed to create .kilocode symlinks');
   }
   
-  // Step 8: Generate CLAUDE.md and QWEN.md
+  // Step 8: Generate CLAUDE.md, QWEN.md and .kilocodemodes
   generateClaudeMd(workflowRoot, projectRoot, packageRoot);
   generateQwenMd(workflowRoot, projectRoot, packageRoot);
-  result.steps.push('Generated CLAUDE.md and QWEN.md from agent-templates');
+  generateKilocodemodes(projectRoot, packageRoot);
+  result.steps.push('Generated CLAUDE.md, QWEN.md and .kilocodemodes from agent-templates');
   
   // Step 9: Update .gitignore
   updateGitignore(projectRoot);

package/src/junction-manager.mjs

@@ -109,24 +109,59 @@ export function createSkillJunctions(globalDir, projectSkillsDir) {
   }
 }
 
-export function createScriptHardlinks(globalDir, projectScriptsDir) {
+export function createScriptJunction(globalDir, projectScriptsDir) {
   const globalScriptsDir = join(globalDir, 'scripts');
   if (!existsSync(globalScriptsDir)) {
     return;
   }
-  if (!existsSync(projectScriptsDir)) {
-    mkdirSync(projectScriptsDir, { recursive: true });
+
+  // If local (ejected) scripts dir exists, don't overwrite
+  if (existsSync(projectScriptsDir) && !isJunction(projectScriptsDir)) {
+    return;
   }
 
-  const files = readdirSync(globalScriptsDir);
-  for (const file of files) {
-    const targetPath = join(globalScriptsDir, file);
-    const stats = lstatSync(targetPath);
-    if (stats.isFile()) {
-      const linkPath = join(projectScriptsDir, file);
-      createHardlink(targetPath, linkPath);
-    }
+  createJunction(globalScriptsDir, projectScriptsDir);
+}
+
+export function createConfigJunction(globalDir, projectConfigDir) {
+  const globalConfigDir = join(globalDir, 'configs');
+  if (!existsSync(globalConfigDir)) {
+    return;
+  }
+
+  // If local (ejected) config dir exists, don't overwrite
+  if (existsSync(projectConfigDir) && !isJunction(projectConfigDir)) {
+    return;
+  }
+
+  createJunction(globalConfigDir, projectConfigDir);
+}
+
+export function ejectConfigs(globalDir, projectConfigDir) {
+  const globalConfigDir = join(globalDir, 'configs');
+
+  if (!existsSync(globalConfigDir)) {
+    throw new Error('Configs do not exist in global dir');
   }
+
+  removeJunction(projectConfigDir);
+  cpSync(globalConfigDir, projectConfigDir, { recursive: true });
+}
+
+export function ejectScripts(globalDir, projectScriptsDir) {
+  const globalScriptsDir = join(globalDir, 'scripts');
+
+  if (!existsSync(globalScriptsDir)) {
+    throw new Error('Scripts do not exist in global dir');
+  }
+
+  removeJunction(projectScriptsDir);
+  cpSync(globalScriptsDir, projectScriptsDir, { recursive: true });
+}
+
+/** @deprecated Use createScriptJunction instead */
+export function createScriptHardlinks(globalDir, projectScriptsDir) {
+  createScriptJunction(globalDir, projectScriptsDir);
 }
 
 export function ejectSkill(skillName, globalDir, projectSkillsDir) {

package/src/runner.mjs

@@ -543,30 +543,46 @@ class ResultParser {
 // FileGuard — защита файлов от несанкционированного изменения агентами
 // ============================================================================
 class FileGuard {
-  constructor(patterns, projectRoot = process.cwd(), trustedAgents = []) {
-    // Паттерны указаны относительно корня проекта
-    this.patterns = (patterns || []).map(p => p.replace(/\\/g, '/'));
-    this.enabled = this.patterns.length > 0;
+  constructor(patterns, projectRoot = process.cwd(), trustedAgents = [], trustedStages = []) {
+    this.enabled = patterns && patterns.length > 0;
     this.snapshots = new Map();
+    this.patterns = (patterns || []).map(p => {
+      if (typeof p === 'string') {
+        return { pattern: p.replace(/\\/g, '/'), mode: 'full' };
+      }
+      return { pattern: p.pattern.replace(/\\/g, '/'), mode: p.mode || 'full' };
+    });
     // projectRoot — корневая директория проекта, относительно которой указаны паттерны
     this.projectRoot = projectRoot;
     // Доверенные агенты — для них FileGuard не откатывает изменения
     this.trustedAgents = trustedAgents;
+    // Доверенные стейджи — для них FileGuard не откатывает изменения
+    this.trustedStages = trustedStages;
   }
 
   /**
-   * Проверяет, является ли агент доверенным (пропускает FileGuard)
+   * Проверяет, является ли агент или стейдж доверенным (пропускает FileGuard)
    * Поддерживает glob-паттерны: "script-*" соответствует "script-move", "script-pick" и т.д.
    * @param {string} agentId - ID агента
+   * @param {string} [stageId] - ID стейджа (опционально)
    * @returns {boolean}
    */
-  isTrusted(agentId) {
-    return this.trustedAgents.some(pattern => {
+  isTrusted(agentId, stageId) {
+    // Проверка по trustedAgents (glob-паттерны)
+    const agentMatch = this.trustedAgents.some(pattern => {
       if (pattern.endsWith('*')) {
         return agentId.startsWith(pattern.slice(0, -1));
       }
       return agentId === pattern;
     });
+    if (agentMatch) return true;
+
+    // Проверка по trustedStages (точное совпадение)
+    if (stageId && this.trustedStages.includes(stageId)) {
+      return true;
+    }
+
+    return false;
   }
 
   /**
@@ -575,9 +591,8 @@ class FileGuard {
    * @returns {boolean}
    */
   matchesProtected(filePath) {
-    // Получаем относительный путь от projectRoot для сопоставления с паттерном
     const relativePath = path.relative(this.projectRoot, filePath).replace(/\\/g, '/');
-    return this.patterns.some(pattern => this._matchGlob(relativePath, pattern));
+    return this.patterns.some(p => this._matchGlob(relativePath, p.pattern));
   }
 
   /**
@@ -649,20 +664,26 @@ class FileGuard {
     if (!this.enabled) return;
     this.snapshots.clear();
 
-    for (const pattern of this.patterns) {
+    for (const { pattern, mode } of this.patterns) {
       if (!pattern.includes('*')) {
-        // Прямой путь к файлу — преобразуем в абсолютный
         const absolutePath = path.resolve(this.projectRoot, pattern);
         if (fs.existsSync(absolutePath)) {
-          this.snapshots.set(absolutePath, this._hashFile(absolutePath));
+          if (mode === 'structure') {
+            this.snapshots.set(absolutePath, { hash: this._hashFile(absolutePath), content: fs.readFileSync(absolutePath, null), mode: 'structure' });
+          } else {
+            this.snapshots.set(absolutePath, this._hashFile(absolutePath));
+          }
         }
       } else {
-        // Glob-паттерн: сканируем базовую директорию относительно projectRoot
         const baseDir = path.resolve(this.projectRoot, this._getBaseDir(pattern));
         const files = this._getAllFiles(baseDir);
         for (const filePath of files) {
           if (this.matchesProtected(filePath)) {
-            this.snapshots.set(filePath, this._hashFile(filePath));
+            if (mode === 'structure') {
+              this.snapshots.set(filePath, { hash: this._hashFile(filePath), content: fs.readFileSync(filePath, null), mode: 'structure' });
+            } else {
+              this.snapshots.set(filePath, this._hashFile(filePath));
+            }
           }
         }
       }
@@ -681,18 +702,30 @@ class FileGuard {
 
     const violations = [];
 
-    // 1. Проверяем файлы из снимка (изменённые или удалённые)
-    for (const [filePath, originalHash] of this.snapshots) {
-      const currentHash = this._hashFile(filePath);
-      if (currentHash !== originalHash) {
-        violations.push(filePath);
-        console.warn(`[FileGuard] WARNING: Protected file modified: ${filePath}`);
-        this._rollbackFile(filePath);
+    for (const [filePath, snapshot] of this.snapshots) {
+      const mode = snapshot.mode || 'full';
+      if (mode === 'structure') {
+        if (!fs.existsSync(filePath)) {
+          violations.push(filePath);
+          console.warn(`[FileGuard] WARNING: Protected file deleted: ${filePath}`);
+          try {
+            fs.writeFileSync(filePath, snapshot.content);
+            console.warn(`[FileGuard] WARNING: Restored deleted file: ${filePath}`);
+          } catch (err) {
+            console.error(`[FileGuard] ERROR: Failed to restore ${filePath}: ${err.message}`);
+          }
+        }
+      } else {
+        const currentHash = this._hashFile(filePath);
+        if (currentHash !== snapshot) {
+          violations.push(filePath);
+          console.warn(`[FileGuard] WARNING: Protected file modified: ${filePath}`);
+          this._rollbackFile(filePath);
+        }
       }
     }
 
-    // 2. Обнаруживаем новые файлы в защищённых директориях
-    for (const pattern of this.patterns) {
+    for (const { pattern, mode } of this.patterns) {
       const baseDir = pattern.includes('*')
         ? path.resolve(this.projectRoot, this._getBaseDir(pattern))
         : path.resolve(this.projectRoot, pattern);
@@ -848,8 +881,8 @@ class StageExecutor {
       console.log(`  Skill: ${stage.skill}`);
     }
 
-    // Снимаем snapshot защищённых файлов перед выполнением (кроме trusted agents)
-    const skipGuard = this.fileGuard && this.fileGuard.isTrusted(agentId);
+    // Снимаем snapshot защищённых файлов перед выполнением (кроме trusted agents и trusted stages)
+    const skipGuard = this.fileGuard && this.fileGuard.isTrusted(agentId, stageId);
     if (this.fileGuard && !skipGuard) {
       this.fileGuard.takeSnapshot();
     }
@@ -1195,7 +1228,8 @@ class PipelineRunner {
     // Инициализация FileGuard для защиты файлов от изменений агентами
     const protectedPatterns = this.pipeline.protected_files || [];
     const trustedAgents = this.pipeline.trusted_agents || [];
-    this.fileGuard = new FileGuard(protectedPatterns, projectRoot, trustedAgents);
+    const trustedStages = this.pipeline.trusted_stages || [];
+    this.fileGuard = new FileGuard(protectedPatterns, projectRoot, trustedAgents, trustedStages);
     this.projectRoot = projectRoot;
     this.currentExecutor = null;
 

package/src/scripts/check-conditions.js

@@ -36,6 +36,7 @@ const TICKETS_DIR = path.join(WORKFLOW_DIR, 'tickets');
 const BACKLOG_DIR = path.join(TICKETS_DIR, 'backlog');
 const READY_DIR = path.join(TICKETS_DIR, 'ready');
 const DONE_DIR = path.join(TICKETS_DIR, 'done');
+const ARCHIVE_DIR = path.join(TICKETS_DIR, 'archive');
 
 /**
  * Проверяет одно условие тикета
@@ -53,7 +54,10 @@ function checkCondition(condition) {
     case 'tasks_completed': {
       if (!value || (Array.isArray(value) && value.length === 0)) return true;
       const ids = Array.isArray(value) ? value : [value];
-      return ids.every(taskId => fs.existsSync(path.join(DONE_DIR, `${taskId}.md`)));
+      return ids.every(taskId =>
+        fs.existsSync(path.join(DONE_DIR, `${taskId}.md`)) ||
+        fs.existsSync(path.join(ARCHIVE_DIR, `${taskId}.md`))
+      );
     }
 
     case 'date_after':
@@ -76,7 +80,10 @@ function checkCondition(condition) {
  */
 function checkDependencies(dependencies) {
   if (!dependencies || dependencies.length === 0) return true;
-  return dependencies.every(depId => fs.existsSync(path.join(DONE_DIR, `${depId}.md`)));
+  return dependencies.every(depId =>
+    fs.existsSync(path.join(DONE_DIR, `${depId}.md`)) ||
+    fs.existsSync(path.join(ARCHIVE_DIR, `${depId}.md`))
+  );
 }
 
 /**

package/src/scripts/check-relevance.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+
+/**
+ * check-relevance.js - Скрипт проверки актуальности тикета
+ *
+ * Использование:
+ *   node check-relevance.js <path-to-ticket>
+ *
+ * Вывод:
+ *   ---RESULT---
+ *   verdict: relevant|irrelevant
+ *   reason: ...
+ *   ---RESULT---
+ */
+
+import fs from "fs";
+import path from "path";
+import YAML from "../lib/js-yaml.mjs";
+import { findProjectRoot } from "../lib/find-root.mjs";
+import {
+  parseFrontmatter,
+  serializeFrontmatter,
+  getLastReviewStatus,
+} from "../lib/utils.mjs";
+
+const PROJECT_DIR = findProjectRoot();
+const WORKFLOW_DIR = path.join(PROJECT_DIR, ".workflow");
+const TICKETS_DIR = path.join(WORKFLOW_DIR, "tickets");
+
+const VALID_STATUSES = [
+  "backlog",
+  "ready",
+  "in-progress",
+  "blocked",
+  "review",
+  "done",
+  "archive",
+];
+
+function getCurrentStatus(ticketPath) {
+  const fileName = path.basename(ticketPath);
+  for (const status of VALID_STATUSES) {
+    const statusDir = path.join(TICKETS_DIR, status);
+    const expectedPath = path.join(statusDir, fileName);
+    if (ticketPath === expectedPath) {
+      return status;
+    }
+  }
+  return null;
+}
+
+function extractPlanId(parentPlan) {
+  if (!parentPlan) return null;
+  const basename = path.basename(parentPlan, ".md");
+  const match = basename.match(/^PLAN-(\d+)$/i);
+  if (match) {
+    return `PLAN-${String(parseInt(match[1], 10)).padStart(3, "0")}`;
+  }
+  return basename;
+}
+
+function getDodCompletion(content) {
+  const dodSectionMatch = content.match(/## Критерии готовности.*?\n([\s\S]*?)(?=\n## |\n# |\z)/i);
+  if (!dodSectionMatch) return { completed: false, total: 0, checked: 0 };
+
+  const section = dodSectionMatch[1];
+  const checkedMatches = section.match(/\[x\]/gi) || [];
+  const uncheckedMatches = section.match(/\[ \]/gi) || [];
+
+  const total = checkedMatches.length + uncheckedMatches.length;
+  const completed = total > 0 && uncheckedMatches.length === 0;
+
+  return { completed, total, checked: checkedMatches.length };
+}
+
+function hasResultSection(content) {
+  const resultPatterns = [
+    /##\s*Result/gi,
+    /##\s*Результат/gi,
+    /##\s*Результат выполнения/gi,
+  ];
+  return resultPatterns.some((pattern) => pattern.test(content));
+}
+
+function getBlockedSection(content) {
+  const blockedMatch = content.match(/##\s*Блокировки\s*\n([\s\S]*?)(?=\n## |\n# |\z)/i);
+  return blockedMatch ? blockedMatch[1].trim() : "";
+}
+
+function findTicketInColumns(ticketId) {
+  for (const status of VALID_STATUSES) {
+    const statusDir = path.join(TICKETS_DIR, status);
+    const ticketPath = path.join(statusDir, `${ticketId}.md`);
+    if (fs.existsSync(ticketPath)) {
+      return status;
+    }
+  }
+  return null;
+}
+
+async function checkRelevance(ticketPath) {
+  if (!fs.existsSync(ticketPath)) {
+    return {
+      verdict: "relevant",
+      reason: "file_not_found",
+      error: `Ticket file not found: ${ticketPath}`,
+    };
+  }
+
+  let content;
+  try {
+    content = fs.readFileSync(ticketPath, "utf8");
+  } catch (e) {
+    return {
+      verdict: "relevant",
+      reason: "read_error",
+      error: `Failed to read ticket: ${e.message}`,
+    };
+  }
+
+  let frontmatter, body;
+  try {
+    ({ frontmatter, body } = parseFrontmatter(content));
+  } catch (e) {
+    return {
+      verdict: "relevant",
+      reason: "invalid_frontmatter",
+      warning: `Failed to parse frontmatter: ${e.message}. Treating as relevant (fail-safe).`,
+    };
+  }
+
+  const currentStatus = getCurrentStatus(ticketPath);
+  const fullContent = body;
+
+  const lastReview = getLastReviewStatus(fullContent);
+  if (lastReview === "skipped") {
+    return { verdict: "irrelevant", reason: "already_skipped" };
+  }
+  if (lastReview === "failed") {
+    return { verdict: "relevant", reason: "review_failed_needs_rework" };
+  }
+
+  if (frontmatter.blocked === true || frontmatter.blocked === "true") {
+    return { verdict: "relevant", reason: "blocked" };
+  }
+
+  const blockedSection = getBlockedSection(fullContent);
+  const hasActiveBlockers = blockedSection.length > 0 && !blockedSection.includes("нет");
+  if (hasActiveBlockers) {
+    return { verdict: "relevant", reason: "blocked" };
+  }
+
+  const parentPlan = frontmatter.parent_plan;
+  if (parentPlan) {
+    const planId = extractPlanId(parentPlan);
+    if (planId) {
+      const planPath = path.join(WORKFLOW_DIR, "plans", "current", `${planId}.md`);
+      if (fs.existsSync(planPath)) {
+        try {
+          const planContent = fs.readFileSync(planPath, "utf8");
+          const { frontmatter: planFm } = parseFrontmatter(planContent);
+          const planStatus = planFm.status;
+          if (["completed", "archived", "cancelled"].includes(planStatus)) {
+            return { verdict: "irrelevant", reason: "plan_inactive" };
+          }
+        } catch (e) {
+          // fail-safe: treat as relevant
+        }
+      } else {
+        // fail-safe: treat as relevant
+      }
+    }
+  } else {
+    // fail-safe: parent_plan is empty
+  }
+
+  const dod = getDodCompletion(fullContent);
+  const hasResult = hasResultSection(fullContent);
+
+  if (dod.completed && hasResult) {
+    if (lastReview === "passed") {
+      return { verdict: "irrelevant", reason: "dod_completed" };
+    } else if (lastReview === null) {
+      return { verdict: "relevant", reason: "needs_review" };
+    }
+  }
+
+  const dependencies = frontmatter.dependencies || [];
+  if (dependencies.length > 0) {
+    for (const dep of dependencies) {
+      const depStatus = findTicketInColumns(dep);
+      if (depStatus === null) {
+        return { verdict: "irrelevant", reason: "dependencies_inactive" };
+      }
+      if (depStatus === "blocked") {
+        try {
+          const blockedDir = path.join(TICKETS_DIR, "blocked", `${dep}.md`);
+          const blockedContent = fs.readFileSync(blockedDir, "utf8");
+          const { body: blockedBody } = parseFrontmatter(blockedContent);
+          if (blockedBody.toLowerCase().includes("неактуально")) {
+            return { verdict: "irrelevant", reason: "dependencies_inactive" };
+          }
+        } catch (e) {
+          // ignore
+        }
+      }
+    }
+  }
+
+  return { verdict: "relevant", reason: "all_checks_passed" };
+}
+
+function addSkippedReview(ticketPath, reason) {
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10);
+
+  let content;
+  try {
+    content = fs.readFileSync(ticketPath, "utf8");
+  } catch (e) {
+    throw new Error(`Failed to read ticket: ${e.message}`);
+  }
+
+  let { frontmatter, body } = parseFrontmatter(content);
+
+  const reviewSectionMatch = body.match(/##\s*Ревью\s*\n([\s\S]*)/i);
+  let newBody;
+
+  if (reviewSectionMatch) {
+    const reviewContent = reviewSectionMatch[1];
+    const lines = reviewContent.split("\n");
+    let insertIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].trim().startsWith("|") && lines[i].includes("---")) {
+        insertIndex = i + 1;
+        break;
+      }
+    }
+
+    const newRow = `| ${date} | ⏭️ skipped | ${reason} |`;
+    lines.splice(insertIndex, 0, newRow);
+    newBody = body.slice(0, reviewSectionMatch.index) + lines.join("\n");
+  } else {
+    const reviewTable = `\n## Ревью\n\n| Дата | Статус | Самари |\n|------|--------|--------|\n| ${date} | ⏭️ skipped | ${reason} |\n`;
+    newBody = body.trimEnd() + reviewTable;
+  }
+
+  const newContent = serializeFrontmatter(frontmatter) + newBody;
+  fs.writeFileSync(ticketPath, newContent, "utf8");
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  let ticketPath;
+
+  if (args.length === 0) {
+    console.error("Usage: node check-relevance.js <path-to-ticket>");
+    console.error("Example: node check-relevance.js .workflow/tickets/in-progress/IMPL-001.md");
+    process.exit(1);
+  } else if (args.length === 1) {
+    const prompt = args[0];
+    const ticketMatch = prompt.match(/ticket_id:\s*(\S+)/);
+    if (ticketMatch) {
+      const ticketId = ticketMatch[1];
+      ticketPath = path.join(TICKETS_DIR, "in-progress", `${ticketId}.md`);
+    } else {
+      ticketPath = args[0];
+    }
+  } else {
+    ticketPath = args[0];
+  }
+
+  if (!path.isAbsolute(ticketPath)) {
+    ticketPath = path.resolve(process.cwd(), ticketPath);
+  }
+
+  const result = await checkRelevance(ticketPath);
+
+  if (result.warning && !result.error) {
+    console.error(`[WARNING] ${result.warning}`);
+  }
+
+  if (result.error) {
+    console.error(`[ERROR] ${result.error}`);
+  }
+
+  if (result.verdict === "irrelevant") {
+    try {
+      addSkippedReview(ticketPath, result.reason);
+    } catch (e) {
+      console.error(`[ERROR] Failed to add review entry: ${e.message}`);
+    }
+  }
+
+  console.log("---RESULT---");
+  console.log(`verdict: ${result.verdict}`);
+  console.log(`reason: ${result.reason}`);
+  console.log("---RESULT---");
+
+  if (result.error) {
+    process.exit(1);
+  }
+}
+
+main().catch((e) => {
+  console.error("[FATAL]", e.message);
+  process.exit(1);
+});

package/src/scripts/get-next-id.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+/**
+ * get-next-id.js - Универсальный генератор ID для тикетов, планов и других артефактов
+ *
+ * Использование:
+ *   node get-next-id.js --prefix TASK --dir tickets
+ *   node get-next-id.js --prefix PLAN --dir plans
+ *
+ * Вывод: следующий ID через ---RESULT---, например: TASK-007
+ */
+
+import fs from "fs";
+import path from "path";
+import { findProjectRoot } from "workflow-ai/lib/find-root.mjs";
+import { printResult } from "workflow-ai/lib/utils.mjs";
+
+const PROJECT_DIR = findProjectRoot();
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let prefix = null;
+  let dir = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--prefix" && i + 1 < args.length) {
+      prefix = args[i + 1];
+      i++;
+    } else if (args[i] === "--dir" && i + 1 < args.length) {
+      dir = args[i + 1];
+      i++;
+    }
+  }
+
+  return { prefix, dir };
+}
+
+function findMaxNumber(targetDir, prefix) {
+  let maxNum = 0;
+  const regex = new RegExp(`^${prefix}-(\\d{3})\\.md$`, "i");
+
+  function scanDirectory(dir) {
+    if (!fs.existsSync(dir)) {
+      return;
+    }
+
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        scanDirectory(fullPath);
+      } else if (entry.isFile()) {
+        const match = entry.name.match(regex);
+        if (match) {
+          const num = parseInt(match[1], 10);
+          if (num > maxNum) {
+            maxNum = num;
+          }
+        }
+      }
+    }
+  }
+
+  scanDirectory(targetDir);
+  return maxNum;
+}
+
+function formatNumber(num) {
+  return num.toString().padStart(3, "0");
+}
+
+async function main() {
+  const { prefix, dir } = parseArgs();
+
+  if (!prefix || !dir) {
+    console.error("Usage: node get-next-id.js --prefix <PREFIX> --dir <DIRECTORY>");
+    console.error("Example: node get-next-id.js --prefix TASK --dir tickets");
+    printResult({
+      status: "error",
+      error: "Missing required arguments: --prefix and --dir",
+    });
+    process.exit(1);
+  }
+
+  let targetDir;
+
+  if (dir === "tickets") {
+    targetDir = path.join(PROJECT_DIR, ".workflow", "tickets");
+  } else if (dir === "plans") {
+    targetDir = path.join(PROJECT_DIR, ".workflow", "plans");
+  } else {
+    targetDir = path.join(PROJECT_DIR, dir);
+  }
+
+  if (!fs.existsSync(targetDir)) {
+    const nextId = `${prefix}-001`;
+    printResult({ status: "success", id: nextId });
+    return;
+  }
+
+  const maxNum = findMaxNumber(targetDir, prefix);
+  const nextNum = maxNum + 1;
+  const nextId = `${prefix}-${formatNumber(nextNum)}`;
+
+  printResult({ status: "success", id: nextId });
+}
+
+main();

package/src/scripts/move-to-review.js

@@ -27,6 +27,7 @@ const PROJECT_DIR = findProjectRoot();
 const TICKETS_DIR = path.join(PROJECT_DIR, ".workflow", "tickets");
 const IN_PROGRESS_DIR = path.join(TICKETS_DIR, "in-progress");
 const REVIEW_DIR = path.join(TICKETS_DIR, "review");
+const ARCHIVE_DIR = path.join(TICKETS_DIR, "archive");
 
 /**
  * Парсит ticket_id из промпта (контекста pipeline runner)
@@ -54,6 +55,7 @@ function moveToReview(ticketId) {
       };
     }
     const donePath = path.join(TICKETS_DIR, "done", `${ticketId}.md`);
+    const archivePath = path.join(ARCHIVE_DIR, `${ticketId}.md`);
     if (fs.existsSync(donePath)) {
       // Проверяем, есть ли у тикета ревью — если нет, перемещаем в review/
       const doneContent = fs.readFileSync(donePath, "utf8");
@@ -81,6 +83,13 @@ function moveToReview(ticketId) {
         reason: `${ticketId} already in done/ with review`,
       };
     }
+    if (fs.existsSync(archivePath)) {
+      return {
+        status: "skipped",
+        ticket_id: ticketId,
+        reason: `${ticketId} already in archive/`,
+      };
+    }
     return {
       status: "error",
       ticket_id: ticketId,

package/src/scripts/pick-next-task.js

@@ -543,6 +543,25 @@ function pickNextTicket(planId) {
       return false;
     }
 
+    // Обнаружение и удаление дубликатов: тикет не должен существовать в других колонках
+    const ticketFileName = `${ticket.id}.md`;
+    const otherDirs = [DONE_DIR, IN_PROGRESS_DIR, REVIEW_DIR, BLOCKED_DIR];
+    const duplicateDir = otherDirs.find(dir =>
+      fs.existsSync(path.join(dir, ticketFileName))
+    );
+    if (duplicateDir) {
+      const dirName = path.basename(duplicateDir);
+      logger.warn(`Duplicate detected: ${ticket.id} exists in ready/ and ${dirName}/. Moving ready/ copy to archive/`);
+      const archivePath = path.join(ARCHIVE_DIR, ticketFileName);
+      try {
+        fs.mkdirSync(ARCHIVE_DIR, { recursive: true });
+        fs.renameSync(ticket.filePath, archivePath);
+      } catch (err) {
+        logger.error(`Failed to archive duplicate ${ticket.id}: ${err.message}`);
+      }
+      return false;
+    }
+
     return true;
   });