convoke-agents 3.0.4 → 3.2.0

package/scripts/portability/validate-exports.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+/**
+ * validate-exports.js — Story sp-4-2
+ *
+ * Structural validation of a staging directory produced by seed-catalog-repo.js.
+ * Checks every exported skill for markdown validity, forbidden strings, persona
+ * sections, platform install instructions, and generates a VALIDATION-REPORT.md
+ * with automated results + manual test checklists.
+ *
+ * Usage:
+ *   node scripts/portability/validate-exports.js --input <path>
+ *   node scripts/portability/validate-exports.js --input <path> --report <path>
+ *   node scripts/portability/validate-exports.js --help
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+
+const { FORBIDDEN_STRINGS } = require('./test-constants');
+
+const XML_TAGS = [
+  '<workflow>', '</workflow>', '<step ', '</step>', '<action>', '</action>',
+  '<check ', '</check>', '<critical>', '</critical>', '<output>', '</output>',
+  '<ask>', '</ask>',
+];
+
+const MANUAL_SMOKE_SKILLS = [
+  { name: 'bmad-brainstorming', persona: 'Carson', role: 'brainstorming facilitator' },
+  { name: 'bmad-agent-architect', persona: 'Winston', role: 'system architect' },
+  { name: 'bmad-tea', persona: 'Murat', role: 'test architect' },
+];
+
+// =============================================================================
+// VALIDATION CHECKS
+// =============================================================================
+
+function validateInstructions(filePath, skillName) {
+  const issues = [];
+  if (!fs.existsSync(filePath)) {
+    issues.push({ skill: skillName, file: 'instructions.md', issue: 'file missing' });
+    return issues;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  // Starts with # heading
+  if (!content.startsWith('# ')) {
+    issues.push({ skill: skillName, file: 'instructions.md', issue: 'does not start with # heading' });
+  }
+
+  // Persona section
+  if (!content.includes('## You are')) {
+    issues.push({ skill: skillName, file: 'instructions.md', issue: 'missing ## You are section' });
+  }
+
+  // Workflow section
+  if (!content.includes('## How to proceed')) {
+    issues.push({ skill: skillName, file: 'instructions.md', issue: 'missing ## How to proceed section' });
+  }
+
+  // Forbidden strings
+  for (const forbidden of FORBIDDEN_STRINGS) {
+    if (content.includes(forbidden)) {
+      issues.push({ skill: skillName, file: 'instructions.md', issue: `contains forbidden: "${forbidden}"` });
+    }
+  }
+
+  // XML tags remaining
+  for (const tag of XML_TAGS) {
+    if (content.includes(tag)) {
+      issues.push({ skill: skillName, file: 'instructions.md', issue: `contains XML tag: ${tag}` });
+    }
+  }
+
+  // Frontmatter blocks
+  // Check for YAML frontmatter at the START of the file (no m flag — ^ = string start)
+  if (/^---\n[\s\S]*?\n---\n/.test(content)) {
+    issues.push({ skill: skillName, file: 'instructions.md', issue: 'contains frontmatter block' });
+  }
+
+  // Balanced code fences
+  const fenceCount = (content.match(/^```/gm) || []).length;
+  if (fenceCount % 2 !== 0) {
+    issues.push({ skill: skillName, file: 'instructions.md', issue: `unbalanced code fences (${fenceCount} found)` });
+  }
+
+  // Broken markdown links (links to local files that aren't URLs or anchors)
+  const localLinks = [...content.matchAll(/\[([^\]]*)\]\((?!https?:\/\/|#|mailto:)([^)]+)\)/g)];
+  for (const match of localLinks) {
+    const linkTarget = match[2];
+    // Skip links containing template placeholders or non-path content
+    if (linkTarget.includes('[') || linkTarget.includes('{')) continue;
+    if (linkTarget.includes(' ')) continue; // URLs/paths don't have spaces; this is prose like "(none found)"
+    const resolved = path.resolve(path.dirname(filePath), linkTarget);
+    if (!fs.existsSync(resolved)) {
+      issues.push({ skill: skillName, file: 'instructions.md', issue: `broken link: [${match[1]}](${linkTarget})` });
+    }
+  }
+
+  return issues;
+}
+
+function validateReadme(filePath, skillName) {
+  const issues = [];
+  if (!fs.existsSync(filePath)) {
+    issues.push({ skill: skillName, file: 'README.md', issue: 'file missing' });
+    return issues;
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  // 3 platform sections
+  if (!content.includes('Claude Code')) {
+    issues.push({ skill: skillName, file: 'README.md', issue: 'missing Claude Code section' });
+  }
+  if (!content.includes('Copilot')) {
+    issues.push({ skill: skillName, file: 'README.md', issue: 'missing Copilot section' });
+  }
+  if (!content.includes('Cursor')) {
+    issues.push({ skill: skillName, file: 'README.md', issue: 'missing Cursor section' });
+  }
+
+  // Line count
+  const lineCount = content.split('\n').length;
+  if (lineCount > 80) {
+    issues.push({ skill: skillName, file: 'README.md', issue: `${lineCount} lines (exceeds 80)` });
+  }
+
+  // No HTML comments in output
+  if (content.includes('<!--')) {
+    issues.push({ skill: skillName, file: 'README.md', issue: 'contains HTML comments' });
+  }
+
+  return issues;
+}
+
+function validateStagingDir(inputDir) {
+  const allIssues = [];
+
+  // Check root files
+  if (!fs.existsSync(path.join(inputDir, 'README.md'))) {
+    allIssues.push({ skill: 'ROOT', file: 'README.md', issue: 'missing catalog README' });
+  }
+  if (!fs.existsSync(path.join(inputDir, 'LICENSE'))) {
+    allIssues.push({ skill: 'ROOT', file: 'LICENSE', issue: 'missing' });
+  }
+  if (!fs.existsSync(path.join(inputDir, 'CONTRIBUTING.md'))) {
+    allIssues.push({ skill: 'ROOT', file: 'CONTRIBUTING.md', issue: 'missing' });
+  }
+
+  // Validate each skill directory
+  const entries = fs.readdirSync(inputDir, { withFileTypes: true });
+  const skillDirs = entries
+    .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
+    .map((e) => e.name)
+    .sort();
+
+  for (const skillName of skillDirs) {
+    const skillDir = path.join(inputDir, skillName);
+    allIssues.push(
+      ...validateInstructions(path.join(skillDir, 'instructions.md'), skillName),
+      ...validateReadme(path.join(skillDir, 'README.md'), skillName)
+    );
+  }
+
+  return { issues: allIssues, skillCount: skillDirs.length, skillDirs };
+}
+
+// =============================================================================
+// REPORT GENERATION
+// =============================================================================
+
+function generateReport(inputDir, validationResult) {
+  const { issues, skillCount, skillDirs } = validationResult;
+  const date = new Date().toISOString().slice(0, 10);
+  const passCount = skillDirs.filter(
+    (d) => !issues.some((i) => i.skill === d)
+  ).length;
+  const failCount = skillCount - passCount;
+
+  const lines = [];
+
+  lines.push('# Export Validation Report');
+  lines.push('');
+  lines.push(`**Date:** ${date}`);
+  lines.push(`**Skills validated:** ${skillCount}`);
+  lines.push(`**Automated checks:** ${issues.length === 0 ? 'ALL PASSED' : `${issues.length} issue(s) found`}`);
+  lines.push(`**Pass/Fail:** ${passCount} passed, ${failCount} failed`);
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  // Automated results
+  lines.push('## Automated Structural Checks');
+  lines.push('');
+  if (issues.length === 0) {
+    lines.push('All checks passed across all exported skills.');
+  } else {
+    lines.push('| Skill | File | Issue |');
+    lines.push('|---|---|---|');
+    for (const issue of issues) {
+      lines.push(`| ${issue.skill} | ${issue.file} | ${issue.issue} |`);
+    }
+  }
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  // Manual Claude Code smoke tests
+  lines.push('## Manual Smoke Tests — Claude Code');
+  lines.push('');
+  lines.push('Copy each skill into a clean project and invoke it. Verify persona behavior.');
+  lines.push('');
+  for (const skill of MANUAL_SMOKE_SKILLS) {
+    lines.push(`### ${skill.persona} (${skill.name})`);
+    lines.push('');
+    lines.push(`- [ ] [PENDING] Copied \`${skill.name}/instructions.md\` to \`.claude/skills/${skill.name}/SKILL.md\``);
+    lines.push(`- [ ] [PENDING] Invoked skill — ${skill.persona} introduces self as ${skill.role}`);
+    lines.push(`- [ ] [PENDING] No references to \`_bmad/\`, \`bmad-init\`, or missing files`);
+    lines.push(`- [ ] [PENDING] Skill produces usable output`);
+    lines.push('');
+  }
+  lines.push('---');
+  lines.push('');
+
+  // Manual Catalog walkthrough
+  lines.push('## Manual Catalog Walkthrough');
+  lines.push('');
+  lines.push('Have a teammate unfamiliar with BMAD read the catalog README.');
+  lines.push('');
+  lines.push('- [ ] [PENDING] Reader can identify what each intent category means');
+  lines.push('- [ ] [PENDING] Reader finds a skill matching "I want to brainstorm" within 60 seconds');
+  lines.push('- [ ] [PENDING] Tier badges are clear — "Ready to use" vs "Framework only" understood');
+  lines.push('- [ ] [PENDING] "How to use a skill" section gives enough context to install');
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+  lines.push(`*Generated by validate-exports.js on ${date}.*`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// =============================================================================
+// CLI
+// =============================================================================
+
+function printHelp() {
+  process.stdout.write(
+    [
+      'Usage: validate-exports --input <path> [--report <path>]',
+      '',
+      'Validate a staging directory produced by seed-catalog-repo.js.',
+      '',
+      'Options:',
+      '  --input <path>    Staging directory to validate (required)',
+      '  --report <path>   Write VALIDATION-REPORT.md to this path (optional)',
+      '  --help, -h        Show this help message',
+      '',
+      'Exit codes:',
+      '  0  All checks passed',
+      '  1  Validation failures found',
+      '  2  Usage error',
+      '',
+    ].join('\n')
+  );
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+
+  if (argv.includes('--help') || argv.includes('-h')) {
+    printHelp();
+    return 0;
+  }
+
+  let inputDir = null;
+  let reportPath = null;
+
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--input') {
+      const next = argv[i + 1];
+      if (!next || next.startsWith('--')) {
+        process.stderr.write('Error: --input requires a path argument\n');
+        return 2;
+      }
+      inputDir = argv[++i];
+    } else if (argv[i] === '--report') {
+      const next = argv[i + 1];
+      if (!next || next.startsWith('--')) {
+        process.stderr.write('Error: --report requires a path argument\n');
+        return 2;
+      }
+      reportPath = argv[++i];
+    } else if (argv[i].startsWith('--')) {
+      process.stderr.write(`Unknown flag: ${argv[i]}. Run --help for usage.\n`);
+      return 2;
+    }
+  }
+
+  if (!inputDir) {
+    process.stderr.write('Error: --input <path> is required. Run --help for usage.\n');
+    return 2;
+  }
+
+  if (!fs.existsSync(inputDir)) {
+    process.stderr.write(`Error: input directory "${inputDir}" does not exist\n`);
+    return 2;
+  }
+  if (!fs.statSync(inputDir).isDirectory()) {
+    process.stderr.write(`Error: "${inputDir}" is not a directory\n`);
+    return 2;
+  }
+
+  console.log(`Validating exports in ${inputDir}...`);
+  const result = validateStagingDir(inputDir);
+
+  if (result.issues.length === 0) {
+    console.log(`All checks passed (${result.skillCount} skills validated)`);
+  } else {
+    console.log(`${result.issues.length} issue(s) found across ${result.skillCount} skills:`);
+    for (const issue of result.issues) {
+      console.log(`  ${issue.skill}/${issue.file}: ${issue.issue}`);
+    }
+  }
+
+  if (reportPath) {
+    const report = generateReport(inputDir, result);
+    const reportDir = path.dirname(reportPath);
+    fs.mkdirSync(reportDir, { recursive: true });
+    fs.writeFileSync(reportPath, report);
+    console.log(`Validation report written to ${reportPath}`);
+  }
+
+  return result.issues.length === 0 ? 0 : 1;
+}
+
+if (require.main === module) {
+  process.exit(main());
+}
+
+module.exports = { validateStagingDir, generateReport, main };

package/scripts/update/lib/agent-registry.js

@@ -198,6 +198,39 @@ const GYRE_AGENT_FILES = GYRE_AGENTS.map(a => `${a.id}.md`);
 const GYRE_AGENT_IDS = GYRE_AGENTS.map(a => a.id);
 const GYRE_WORKFLOW_NAMES = GYRE_WORKFLOWS.map(w => w.name);
 
+// Standalone bme agents that don't fit the Vortex/Gyre team pattern.
+// These agents live in their own submodule (not _vortex or _gyre) and are
+// individually registered. refresh-installation.js and validator.js both
+// consume this list to preserve and validate them.
+//
+// Each entry must include:
+//   - id: kebab-case identifier (becomes bmad-agent-bme-{id})
+//   - submodule: directory under _bmad/bme/ (e.g., '_team-factory')
+//   - name: displayName for manifest
+//   - title: persona title
+//   - icon: emoji
+//   - role: persona role string
+//   - identity: persona identity description
+//   - communication_style: persona voice
+//   - expertise: principles/expertise bullets
+const EXTRA_BME_AGENTS = [
+  {
+    id: 'team-factory',
+    submodule: '_team-factory',
+    name: 'Loom Master',
+    title: 'Team Factory',
+    icon: '🏭',
+    persona: {
+      role: 'Team Architecture Specialist + BMAD Compliance Expert',
+      identity: 'Master team architect who guides framework contributors through creating fully-wired, BMAD-compliant teams. Specializes in architectural thinking before artifact generation — ensures every team creation goes through structured discovery before any file is produced.',
+      communication_style: 'Methodical yet encouraging — like a senior architect pair-programming with a colleague. Asks focused questions, explains trade-offs clearly, and celebrates good decisions. Uses concrete examples from Vortex and Gyre to illustrate patterns. Never dumps all decisions at once — progressive disclosure, one step at a time.',
+      expertise: "- Thinking before files: every team creation goes through discovery before generation - BMAD compliance is non-negotiable: output must be indistinguishable from native teams - No orphaned artifacts: if a file is created, it must be registered, wired, and discoverable - Delegate to BMB for artifact generation: factory owns integration wiring only - Validate continuously: don't wait until the end to check"
+    }
+  }
+];
+
+const EXTRA_BME_AGENT_IDS = EXTRA_BME_AGENTS.map(a => a.id);
+
 module.exports = {
   AGENTS,
   WORKFLOWS,
@@ -211,4 +244,6 @@ module.exports = {
   GYRE_AGENT_FILES,
   GYRE_AGENT_IDS,
   GYRE_WORKFLOW_NAMES,
+  EXTRA_BME_AGENTS,
+  EXTRA_BME_AGENT_IDS,
 };

package/scripts/update/lib/config-merger.js

@@ -2,13 +2,23 @@
 
 const fs = require('fs-extra');
 const yaml = require('js-yaml');
+const YAML = require('yaml'); // Comment-preserving YAML library (ag-7-1: I29). Used by mergeConfig + writeConfig to preserve comments across the merge round-trip.
 const { AGENT_IDS, WORKFLOW_NAMES } = require('./agent-registry');
+const { assertVersion } = require('./utils');
 
 /**
  * Config Merger for Convoke
  * Smart YAML merging preserving user settings
+ *
+ * ag-7-1 (I29): mergeConfig now returns a sentinel-tagged structure that carries
+ * the parsed YAML.Document alongside the merged plain-object form. writeConfig
+ * detects the sentinel and writes via the Document API (preserving comments) when
+ * possible, falling back to js-yaml.dump for backwards compatibility with any
+ * caller that passes a bare object.
  */
 
+const MERGED_DOC_SENTINEL = Symbol.for('convoke.config-merger.docMerged');
+
 /**
  * Merge current config with new template while preserving user preferences.
  * Agents and workflows use smart-merge: canonical entries in registry order
@@ -18,20 +28,32 @@ const { AGENT_IDS, WORKFLOW_NAMES } = require('./agent-registry');
  * @param {string} currentConfigPath - Path to current config.yaml
  * @param {string} newVersion - New version to set
  * @param {object} updates - Updates to apply (agents, workflows, etc.)
- * @returns {Promise<object>} Merged config object
+ * @returns {Promise<object>} Merged config object (with hidden Document sentinel for comment preservation)
  */
 async function mergeConfig(currentConfigPath, newVersion, updates = {}) {
+  assertVersion(newVersion, 'config-merger'); // ag-7-1: I30 — fail fast on undefined/null/empty version
+
   let current = {};
+  let doc = null; // YAML.Document for comment preservation
 
   // Read current config if it exists
   if (fs.existsSync(currentConfigPath)) {
     try {
       const currentContent = fs.readFileSync(currentConfigPath, 'utf8');
-      const parsed = yaml.load(currentContent);
-      current = (parsed && typeof parsed === 'object') ? parsed : {};
+      doc = YAML.parseDocument(currentContent);
+      // Note: YAML.parseDocument does not throw on syntax errors — check doc.errors
+      if (doc.errors && doc.errors.length > 0) {
+        console.warn(`Warning: Could not parse current config.yaml (${doc.errors[0].message}), using defaults`);
+        current = {};
+        doc = null;
+      } else {
+        const parsed = doc.toJSON();
+        current = (parsed && typeof parsed === 'object') ? parsed : {};
+      }
     } catch (_error) {
       console.warn('Warning: Could not parse current config.yaml, using defaults');
       current = {};
+      doc = null;
     }
   }
 
@@ -80,6 +102,18 @@ async function mergeConfig(currentConfigPath, newVersion, updates = {}) {
     merged.migration_history = [];
   }
 
+  // ag-7-1 (I29): attach the Document for comment-preserving writes.
+  // writeConfig detects the sentinel and writes via doc.toString() when set;
+  // otherwise it falls back to js-yaml.dump (backwards compat).
+  if (doc) {
+    Object.defineProperty(merged, MERGED_DOC_SENTINEL, {
+      value: doc,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+
   return merged;
 }
 
@@ -194,21 +228,117 @@ function validateConfig(config) {
 }
 
 /**
- * Write config to file
+ * Write config to file.
+ * If the config object carries the merged-doc sentinel from mergeConfig (ag-7-1),
+ * write via the Document API to preserve comments. Otherwise fall back to
+ * js-yaml.dump for backwards compatibility.
+ *
  * @param {string} configPath - Path to write config
- * @param {object} config - Config object
+ * @param {object} config - Config object (optionally carrying a Document sentinel)
  * @returns {Promise<void>}
  */
 async function writeConfig(configPath, config) {
-  const yamlContent = yaml.dump(config, {
-    indent: 2,
-    lineWidth: -1, // Don't wrap long lines
-    noRefs: true
-  });
+  // ag-7-1 (I29) — Comment preservation paths, in order of preference:
+  //
+  // 1. SENTINEL PATH: caller went through `mergeConfig` which attached the parsed
+  //    Document via the MERGED_DOC_SENTINEL symbol. Use it directly. The sentinel
+  //    contract guarantees `merged` is a complete config (mergeConfig produces a
+  //    full structure), so it's safe to delete keys from the Document that aren't
+  //    in `merged` (e.g., a removed user field).
+  // 2. SELF-HEAL PATH: caller passed a bare object (e.g., `migration-runner.js`'s
+  //    `updateMigrationHistory` calling `addMigrationHistory` then `writeConfig`)
+  //    AND the destination file exists. Re-parse the existing file as a Document
+  //    so any comments inside it survive the rewrite. CRITICAL: in the self-heal
+  //    path, we ONLY apply additive/update operations (doc.set for each key the
+  //    caller knows about) — we do NOT delete keys the caller doesn't mention,
+  //    because the bare-object caller may not know about every field on disk
+  //    (e.g., a future caller passing `{ version: '4.0.0' }` to update only the
+  //    version would otherwise wipe out every other top-level field).
+  // 3. FALLBACK PATH: bare object + no existing destination file (fresh install).
+  //    No comments to preserve. Use js-yaml.dump for backwards compatibility.
+  //
+  // CONTRACT NOTE: callers should not reuse the same `merged` object across multiple
+  // `writeConfig` calls. The Document reference inside the sentinel is mutated on
+  // write, so a second call would see an already-mutated Document instead of the
+  // originally parsed state. This is fine for current callers (refresh-installation
+  // calls writeConfig once per merged result) but document the constraint for
+  // future maintainers.
+  const sentinelDoc = config[MERGED_DOC_SENTINEL];
+  let doc = sentinelDoc;
+  const isSentinelPath = !!sentinelDoc;
+
+  if (!doc && fs.existsSync(configPath)) {
+    // Self-heal: re-parse the existing file so its comments survive the rewrite.
+    try {
+      const existingContent = fs.readFileSync(configPath, 'utf8');
+      const reparsed = YAML.parseDocument(existingContent);
+      if (!reparsed.errors || reparsed.errors.length === 0) {
+        doc = reparsed;
+      }
+      // If parse fails, fall through to the bare-object path silently —
+      // the caller is writing a known-good structure either way.
+    } catch (_err) {
+      // Silent — fall through to bare-object path.
+    }
+  }
+
+  let yamlContent;
+  if (doc) {
+    // Comment-preserving path: sync the merged structure into the Document via per-field
+    // doc.set() calls. Replacing doc.contents wholesale would blow away comments attached
+    // to the top-level mapping (e.g., header comments above the first key).
+    // Per-field updates preserve all comment metadata anchored to the document or to fields.
+    const merged = stripSentinel(config);
+
+    // Update existing fields and add new ones
+    for (const key of Object.keys(merged)) {
+      doc.set(key, merged[key]);
+    }
+
+    // Remove keys that were in the original doc but are no longer in the merged structure.
+    // ONLY do this on the SENTINEL path — `mergeConfig` produces a complete config so any
+    // missing key was intentionally removed. On the SELF-HEAL path the caller is a legacy
+    // bare-object caller that may not know about every on-disk field, so deleting unknown
+    // keys would silently destroy user data.
+    if (isSentinelPath && doc.contents && typeof doc.contents.items !== 'undefined') {
+      const mergedKeys = new Set(Object.keys(merged));
+      const docKeys = doc.contents.items.map(item => String(item.key.value));
+      for (const docKey of docKeys) {
+        if (!mergedKeys.has(docKey)) {
+          doc.delete(docKey);
+        }
+      }
+    }
+
+    yamlContent = doc.toString({ lineWidth: 0 });
+  } else {
+    // Backwards-compat path: bare object, no existing file, no comments to preserve.
+    yamlContent = yaml.dump(config, {
+      indent: 2,
+      lineWidth: -1, // Don't wrap long lines
+      noRefs: true
+    });
+  }
 
   await fs.writeFile(configPath, yamlContent, 'utf8');
 }
 
+/**
+ * Return a plain-object copy of config with the sentinel symbol stripped,
+ * so doc.createNode doesn't try to serialize it.
+ * @param {object} config
+ * @returns {object}
+ */
+function stripSentinel(config) {
+  // Symbol-keyed properties are not enumerable in our case (defineProperty above),
+  // but as a safety net we explicitly clone only string-keyed enumerable fields.
+  const plain = {};
+  for (const key of Object.keys(config)) {
+    plain[key] = config[key];
+  }
+  return plain;
+}
+
 /**
  * Add migration history entry
  * @param {object} config - Config object

package/scripts/update/lib/migration-runner.js

@@ -466,7 +466,7 @@ async function runRefreshOnly(fromVersion, options = {}) {
       try {
         await backupManager.restoreBackup(backupMetadata, projectRoot);
         console.log(chalk.green('✓ Installation restored from backup'));
-      } catch (restoreError) {
+      } catch (_restoreError) {
         console.error(chalk.red('✗ Restore failed!'));
         console.error(chalk.yellow(`Manual restore may be needed from: ${backupMetadata.backup_dir}`));
       }