@xulthekl/team-flow 0.22.4

package/scripts/lib/cmd-doctor.mjs

@@ -0,0 +1,267 @@
+// tf doctor — health check for team-flow installation and project
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadConfig } from './config-loader.mjs';
+import { PLATFORM_RUNTIME_INVENTORY } from './platform-runtime-inventory.mjs';
+
+const RUNTIME_SKILLS = new Set([
+  'workflow-start', 'need-explorer', 'spec-writer', 'contract-builder',
+  'build-executor', 'code-reviewer', 'bug-investigator', 'release-archivist', 'spec-merger',
+]);
+
+function readJsonIfExists(filePath) {
+  if (!existsSync(filePath)) return null;
+  try { return JSON.parse(readFileSync(filePath, 'utf-8')); } catch { return null; }
+}
+
+function checkVersionConsistency(root) {
+  const files = [
+    { name: 'package.json', path: ['version'] },
+    { name: 'plugin.json', path: ['version'] },
+    { name: '.claude-plugin/plugin.json', path: ['version'] },
+    { name: '.claude-plugin/marketplace.json', path: ['plugins', '0', 'version'] },
+    { name: '.cursor-plugin/plugin.json', path: ['version'] },
+    { name: '.cursor-plugin/marketplace.json', path: ['metadata', 'version'] },
+    { name: '.codex-plugin/plugin.json', path: ['version'] },
+    { name: 'gemini-extension.json', path: ['version'] },
+    { name: '.github/plugin/marketplace.json', path: ['metadata', 'version'] },
+    { name: '.github/plugin/marketplace.json', path: ['plugins', '0', 'version'] },
+  ];
+
+  const versions = {};
+  for (const f of files) {
+    const key = `${f.name}:${f.path.join('.')}`;
+    const data = readJsonIfExists(join(root, f.name));
+    if (!data) { versions[key] = null; continue; }
+    let val = data;
+    for (const p of f.path) val = val?.[p];
+    versions[key] = val || null;
+  }
+
+  const uniqueVersions = [...new Set(Object.values(versions).filter(Boolean))];
+  const pkgVersion = versions['package.json:version'];
+
+  if (uniqueVersions.length <= 1) {
+    return { pass: true, message: `Version: ${pkgVersion} (consistent across ${Object.keys(versions).filter(k => versions[k]).length} manifest fields)` };
+  }
+  const mismatches = Object.entries(versions)
+    .filter(([, v]) => v !== pkgVersion)
+    .map(([name, v]) => `${name}=${v}`)
+    .join(', ');
+  return { pass: false, message: `Version mismatch: ${pkgVersion} (package.json) vs ${mismatches}` };
+}
+
+function checkHooks(root) {
+  const hooksPath = join(root, 'hooks', 'hooks.json');
+  if (!existsSync(hooksPath)) {
+    return { pass: false, message: 'hooks/hooks.json not found' };
+  }
+  try {
+    const hooks = JSON.parse(readFileSync(hooksPath, 'utf-8'));
+    if (hooks.hooks && typeof hooks.hooks === 'object' && !Array.isArray(hooks.hooks)) {
+      return { pass: true, message: 'valid format' };
+    }
+    return { pass: false, message: 'invalid format (expected record, got ' + typeof hooks.hooks + ')' };
+  } catch (e) {
+    return { pass: false, message: `parse error: ${e.message}` };
+  }
+}
+
+function checkCodexManifest(root) {
+  const manifestPath = join(root, '.codex-plugin', 'plugin.json');
+  const manifest = readJsonIfExists(manifestPath);
+  if (!manifest) {
+    return { pass: false, message: '.codex-plugin/plugin.json not found' };
+  }
+  if (JSON.stringify(manifest.hooks) !== '{}') {
+    return {
+      pass: false,
+      message: 'Codex manifest must set hooks to {} to suppress hooks/hooks.json auto-discovery',
+    };
+  }
+  if (manifest.interface?.category !== 'Developer Tools') {
+    return { pass: false, message: 'Codex category should be Developer Tools' };
+  }
+  return { pass: true, message: 'hooks suppressed, category Developer Tools' };
+}
+
+function checkSkills(root) {
+  const skillsDir = join(root, 'skills');
+  if (!existsSync(skillsDir)) {
+    return { pass: false, message: 'skills/ directory not found' };
+  }
+  const dirs = readdirSync(skillsDir).filter(f => {
+    try { return statSync(join(skillsDir, f)).isDirectory(); } catch { return false; }
+  });
+  const withSkillMd = dirs.filter(d => existsSync(join(skillsDir, d, 'SKILL.md')));
+  if (withSkillMd.length === dirs.length) {
+    return { pass: true, message: `${dirs.length}/${dirs.length} present` };
+  }
+  const missing = dirs.filter(d => !withSkillMd.includes(d));
+  return { pass: false, message: `${withSkillMd.length}/${dirs.length} present, missing SKILL.md: ${missing.join(', ')}` };
+}
+
+function localRuntimePaths(content) {
+  const doubleQuoted = [...content.matchAll(/node\s+"([^"]+\/scripts\/team-flow\.mjs)"/g)]
+    .map(match => match[1]);
+  const singleQuoted = [...content.matchAll(/node\s+'(.+\/scripts\/team-flow\.mjs)'/g)]
+    .map(match => match[1].split("'\\''").join("'"));
+  return [...doubleQuoted, ...singleQuoted];
+}
+
+function checkRuntimeDistribution(root) {
+  const pkg = readJsonIfExists(join(root, 'package.json'));
+  const skillsDir = join(root, 'skills');
+  if (!pkg?.version || !existsSync(skillsDir)) {
+    return { pass: false, message: 'runtime distribution cannot be checked: package.json or skills/ is missing; reinstall team-flow' };
+  }
+
+  const canonicalPrefix = `npx --yes --package @xulthekl/team-flow@${pkg.version} tf`;
+  const issues = [];
+  for (const name of readdirSync(skillsDir)) {
+    if (!RUNTIME_SKILLS.has(name)) continue;
+    const skillPath = join(skillsDir, name, 'SKILL.md');
+    if (!existsSync(skillPath)) continue;
+    const content = readFileSync(skillPath, 'utf8');
+    if (/\$\{CLAUDE_PLUGIN_ROOT\}|\$\{PLUGIN_ROOT\}/.test(content)) {
+      issues.push(`${name}: plugin-root placeholder remains`);
+      continue;
+    }
+    if (content.includes(canonicalPrefix)) continue;
+    const localPaths = localRuntimePaths(content);
+    if (localPaths.length > 0) {
+      if (localPaths.every(existsSync)) continue;
+      issues.push(`${name}: local runtime tree is missing`);
+      continue;
+    }
+    issues.push(`${name}: runtime prefix or local runtime tree is missing`);
+  }
+
+  if (issues.length > 0) {
+    return { pass: false, message: `${issues.join('; ')}; reinstall or upgrade team-flow instead of editing skill files manually` };
+  }
+  return { pass: true, message: `${PLATFORM_RUNTIME_INVENTORY.length} platforms inventoried; canonical skills and local runtime are resolvable` };
+}
+
+function checkDist(root) {
+  const distDir = join(root, 'dist');
+  if (!existsSync(distDir)) {
+    return { pass: false, message: 'dist/ not found (run npm run build)' };
+  }
+  const indexJs = join(distDir, 'index.js');
+  if (!existsSync(indexJs)) {
+    return { pass: false, message: 'dist/index.js not found' };
+  }
+  return { pass: true, message: 'compiled' };
+}
+
+function checkRootPluginAuthor(root) {
+  const pluginPath = join(root, 'plugin.json');
+  const plugin = readJsonIfExists(pluginPath);
+  if (!plugin) {
+    return { pass: false, message: 'plugin.json not found' };
+  }
+  if (!plugin.author) {
+    return { pass: false, message: 'missing author field' };
+  }
+  if (typeof plugin.author === 'string') {
+    return { pass: false, message: 'author must be an object (got string)' };
+  }
+  if (typeof plugin.author === 'object' && !Array.isArray(plugin.author) && plugin.author.name) {
+    return { pass: true, message: `author.name = ${plugin.author.name}` };
+  }
+  return { pass: false, message: 'author object must contain a name property' };
+}
+
+function checkNodeVersion(version = process.version) {
+  const major = parseInt(version.slice(1).split('.')[0], 10);
+  if (major >= 20) {
+    return { pass: true, message: version };
+  }
+  return { pass: false, message: `${version} (requires >= 20)` };
+}
+
+function checkDocs(root) {
+  const warnings = [];
+  const pkg = readJsonIfExists(join(root, 'package.json'));
+  if (!pkg) return { pass: true, message: 'skipped (no package.json)' };
+
+  const pkgVersion = pkg.version;
+
+  // Check CHANGELOG has current version
+  const changelogPath = join(root, 'CHANGELOG.md');
+  if (existsSync(changelogPath)) {
+    const changelog = readFileSync(changelogPath, 'utf-8');
+    if (!changelog.includes(`## [${pkgVersion}]`)) {
+      warnings.push(`CHANGELOG.md missing entry for v${pkgVersion}`);
+    }
+  }
+
+  // Check skills count in README
+  const readmePath = join(root, 'README.md');
+  if (existsSync(readmePath)) {
+    const skillsDir = join(root, 'skills');
+    if (existsSync(skillsDir)) {
+      const actualSkills = readdirSync(skillsDir).filter(f => {
+        try { return statSync(join(skillsDir, f)).isDirectory(); } catch { return false; }
+      }).length;
+      const readme = readFileSync(readmePath, 'utf-8');
+      // Count skill table rows (pattern: | N | `skill-name` | where N is a row number)
+      const skillRefs = readme.match(/\|\s*\d+\s*\|\s*`[a-z-]+`/g) || [];
+      if (skillRefs.length > 0 && skillRefs.length !== actualSkills) {
+        warnings.push(`README lists ${skillRefs.length} skills, but skills/ has ${actualSkills}`);
+      }
+    }
+  }
+
+  if (warnings.length === 0) {
+    return { pass: true, message: 'consistent' };
+  }
+  return { pass: false, message: warnings.join('; ') };
+}
+
+export async function run(args) {
+  const root = process.cwd();
+  const config = loadConfig(root);
+
+  console.log('team-flow doctor:\n');
+
+  const checks = [
+    ['Version', checkVersionConsistency(root)],
+    ['Root plugin author', checkRootPluginAuthor(root)],
+    ['Hooks', checkHooks(root)],
+    ['Codex manifest', checkCodexManifest(root)],
+    ['Skills', checkSkills(root)],
+    ['Runtime distribution', checkRuntimeDistribution(root)],
+    ['dist/', checkDist(root)],
+    ['Node.js', checkNodeVersion()],
+    ['Docs', checkDocs(root)],
+  ];
+
+  // Config check
+  const configPath = join(root, 'team-flow.config.json');
+  if (existsSync(configPath)) {
+    try {
+      JSON.parse(readFileSync(configPath, 'utf-8'));
+      checks.push(['Config', { pass: true, message: 'valid JSON' }]);
+    } catch (e) {
+      checks.push(['Config', { pass: false, message: `invalid JSON: ${e.message}` }]);
+    }
+  }
+
+  let hasFailure = false;
+  for (const [name, result] of checks) {
+    const icon = result.pass ? '✅' : '⚠️ ';
+    console.log(`  ${icon} ${name}: ${result.message}`);
+    if (!result.pass) hasFailure = true;
+  }
+
+  console.log('');
+  if (hasFailure) {
+    console.log('⚠️  Some checks need attention.');
+  } else {
+    console.log('✅ All checks passed.');
+  }
+}
+
+export { checkVersionConsistency, checkHooks, checkCodexManifest, checkSkills, checkRuntimeDistribution, checkDist, checkRootPluginAuthor, checkNodeVersion, checkDocs };

package/scripts/lib/cmd-execution.mjs

@@ -0,0 +1,206 @@
+import { parseArgs } from 'node:util';
+import { createPlan, describeWaves, EXECUTION_MODES, readPlan, recordReview, validatePlan, writePlan } from './execution-plan.mjs';
+import {
+  createRecommendationReceipt,
+  readCurrentRecommendationReceipt,
+  writeRecommendationReceipt,
+} from './execution-recommendation.mjs';
+import { readState, writeState } from './state-loader.mjs';
+
+const SUBCOMMANDS = ['recommend', 'plan', 'show', 'revise', 'review'];
+
+export async function run(args) {
+  const { positionals, values } = parseArgs({
+    args,
+    options: {
+      mode: { type: 'string' },
+      reason: { type: 'string' },
+      wave: { type: 'string', multiple: true },
+      confirm: { type: 'boolean', default: false },
+      'acknowledge-recommendation': { type: 'boolean', default: false },
+      base: { type: 'string' },
+      head: { type: 'string' },
+      report: { type: 'string' },
+      verdict: { type: 'string' },
+      json: { type: 'boolean', default: false },
+      help: { type: 'boolean', default: false },
+    },
+    allowPositionals: true,
+  });
+  const subcommand = positionals[0];
+  const changeDir = positionals[1];
+
+  if (values.help || subcommand === undefined) {
+    printHelp();
+    return;
+  }
+  if (!SUBCOMMANDS.includes(subcommand)) usage(`Unknown execution subcommand: ${subcommand}`);
+  if (!changeDir) usage('Usage: tf execution <subcommand> <change-dir> [options]');
+
+  switch (subcommand) {
+    case 'recommend':
+      return recommendAndPrint(changeDir, values);
+    case 'plan':
+      return createAndPrintPlan(changeDir, values, false);
+    case 'show':
+      return showPlan(changeDir, values.json);
+    case 'revise':
+      return createAndPrintPlan(changeDir, values, true);
+    case 'review':
+      return recordAndPrintReview(changeDir, values);
+  }
+}
+
+function createAndPrintPlan(changeDir, values, revise) {
+  requireMode(values.mode);
+  requireOption(values.reason, '--reason');
+  requireSafeReason(values.reason);
+  const waves = parseWaves(values.wave);
+  const existing = readPlan(changeDir);
+  if (revise) {
+    if (!existing) throw new Error('Cannot revise an execution plan before it is created');
+    if (values.mode !== 'sdd') {
+      throw new Error('Execution plan revisions must retain or upgrade to sdd; execution-plan downgrades are not allowed');
+    }
+  } else if (existing) {
+    throw new Error('An execution plan already exists; use "tf execution revise" to create a new SDD revision');
+  }
+  const recommendationReceipt = readCurrentRecommendationReceipt(changeDir, waves, revise ? existing.revision : null);
+  const recommendation = recommendationReceipt.recommendation;
+  if (!recommendation.available_modes.includes(values.mode)) {
+    throw new Error(`${values.mode} is not an available execution mode for this change; choose one of: ${recommendation.available_modes.join(', ')}`);
+  }
+
+  if (!values.confirm) {
+    throw new Error('Execution mode selection requires --confirm after reviewing "tf execution recommend" output');
+  }
+  const followedRecommendation = values.mode === recommendation.recommendation.mode;
+  if (!followedRecommendation && !values['acknowledge-recommendation']) {
+    throw new Error(`${values.mode} differs from the ${recommendation.recommendation.mode} recommendation; pass --acknowledge-recommendation to record the informed choice`);
+  }
+  if (followedRecommendation && values['acknowledge-recommendation']) {
+    throw new Error('--acknowledge-recommendation is only valid when selecting a non-recommended mode');
+  }
+
+  const plan = createPlan(changeDir, {
+    mode: values.mode,
+    source: revise ? 'user-confirmed-revision' : 'user-confirmed',
+    rationale: values.reason,
+    waves,
+    recommendation,
+    recommendationReceipt,
+    selection: {
+      confirmed: true,
+      followed_recommendation: followedRecommendation,
+      acknowledged_non_recommendation: !followedRecommendation,
+    },
+    revision: revise ? existing.revision + 1 : undefined,
+  });
+  const saved = writePlan(changeDir, plan);
+  writeExecutionSummary(changeDir, saved);
+  print(values.json, { ok: true, plan: saved }, `Execution plan revision ${saved.revision} recorded (${saved.mode}).`);
+}
+
+function recommendAndPrint(changeDir, values) {
+  const waves = values.wave?.length ? parseWaves(values.wave) : [];
+  const receipt = writeRecommendationReceipt(changeDir, createRecommendationReceipt(changeDir, waves));
+  const recommendation = receipt.recommendation;
+  const lines = [
+    'Available execution modes:',
+    ...recommendation.available_modes.map(mode => `- ${mode}`),
+    `Recommended: ${recommendation.recommendation.mode}`,
+    ...recommendation.recommendation.reasons.map(reason => `- ${reason}`),
+  ];
+  print(values.json, { ok: true, recommendation, receipt }, lines.join('\n'));
+}
+
+function showPlan(changeDir, json) {
+  const plan = readPlan(changeDir);
+  if (!plan) throw new Error('No execution plan has been recorded');
+  const validation = validatePlan(changeDir, plan);
+  const current = validation.valid;
+  const waves = describeWaves(changeDir, plan);
+  print(json, { ok: current, current, plan, valid: current, failures: validation.failures, waves },
+    validation.valid ? `Execution plan revision ${plan.revision} is current.` : validation.failures.join('\n'));
+  if (!validation.valid) process.exitCode = 1;
+}
+
+function recordAndPrintReview(changeDir, values) {
+  requireOption(values.wave?.[0], '--wave');
+  if (values.wave.length !== 1) throw new Error('Review requires exactly one --wave value');
+  requireOption(values.base, '--base');
+  requireOption(values.head, '--head');
+  requireOption(values.report, '--report');
+  if (!['pass', 'fail'].includes(values.verdict)) throw new Error("--verdict must be 'pass' or 'fail'");
+  const receipt = recordReview(changeDir, values.wave[0], {
+    status: values.verdict,
+    base: values.base,
+    head: values.head,
+    report: values.report,
+  });
+  print(values.json, { ok: true, wave: values.wave[0], receipt }, `Review for ${values.wave[0]} recorded: ${receipt.status}.`);
+}
+
+function writeExecutionSummary(changeDir, plan) {
+  const summary = `${plan.mode}: plan revision ${plan.revision}; ${plan.source}; ${plan.rationale}`;
+  const state = readState(changeDir);
+  state.revision = plan.revision;
+  state.execution_mode = plan.mode;
+  state.execution_plan_hash = plan.hash;
+  state.execution_plan_revision = plan.revision;
+  state.dp_4_result = summary;
+  state.dp_4_timestamp = new Date().toISOString();
+  writeState(changeDir, state);
+}
+
+function parseWaves(values) {
+  if (!values || values.length === 0) throw new Error('At least one --wave <id>:<strategy>:<task,...> is required');
+  return values.map(value => {
+    const [id, strategy, taskList, dependencyList, ...extra] = value.split(':');
+    if (extra.length > 0 || !id || !strategy || !taskList) {
+      throw new Error(`Invalid --wave '${value}'; expected <id>:<strategy>:<task,...>[:<depends-on,...>]`);
+    }
+    const tasks = taskList.split(',').map(task => task.trim()).filter(Boolean);
+    if (tasks.length === 0) throw new Error(`Invalid --wave '${value}'; at least one task is required`);
+    const depends_on = dependencyList === undefined ? [] : dependencyList.split(',').map(id => id.trim()).filter(Boolean);
+    if (dependencyList !== undefined && depends_on.length === 0) {
+      throw new Error(`Invalid --wave '${value}'; dependencies must name at least one wave`);
+    }
+    return { id, strategy, tasks, depends_on };
+  });
+}
+
+function requireMode(mode) {
+  if (!EXECUTION_MODES.includes(mode)) {
+    throw new Error(`--mode must be one of: ${EXECUTION_MODES.join(', ')}`);
+  }
+}
+
+function requireOption(value, option) {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`${option} is required`);
+}
+
+function requireSafeReason(reason) {
+  if (/[\p{Cc}\p{Zl}\p{Zp}]/u.test(reason)) {
+    throw new Error('--reason must not contain control characters or line separators');
+  }
+}
+
+function usage(message) {
+  console.error(message);
+  printHelp();
+  process.exit(2);
+}
+
+function print(json, value, message) {
+  console.log(json ? JSON.stringify(value) : message);
+}
+
+function printHelp() {
+  console.log(`Usage:
+  tf execution recommend <dir> [--wave <id>:<strategy>:<task,...>[:<depends-on,...>]] [--json]
+  tf execution plan <dir> --mode <mode> --confirm --reason <text> --wave <id>:<strategy>:<task,...>[:<depends-on,...>] [--acknowledge-recommendation]
+  tf execution show <dir> [--json]
+  tf execution revise <dir> --mode sdd --confirm --reason <text> --wave <id>:<strategy>:<task,...>[:<depends-on,...>] [--acknowledge-recommendation]
+  tf execution review <dir> --wave <id> --base <sha> --head <sha> --report <path> --verdict pass|fail`);
+}

package/scripts/lib/cmd-handoff.mjs

@@ -0,0 +1,94 @@
+// tf handoff contract lifecycle commands.
+import { parseArgs } from 'node:util';
+import {
+  HANDOFF_DECISIONS, HANDOFF_TYPES, createHandoff, finishHandoff, listHandoffs, resolveHandoff,
+} from './sdd-overlay.mjs';
+
+const USAGE = 'Usage: tf handoff <create|list|finish|resolve> <change-dir> [options]';
+
+export async function run(args) {
+  const { positionals, values } = parseArgs({
+    args,
+    allowPositionals: true,
+    options: {
+      type: { type: 'string' }, objective: { type: 'string' },
+      'expected-output': { type: 'string' }, acceptance: { type: 'string' },
+      boundary: { type: 'string', multiple: true }, decision: { type: 'string' },
+      'acknowledge-source-drift': { type: 'boolean', default: false },
+      json: { type: 'boolean', default: false },
+    },
+  });
+
+  const subcommand = positionals[0];
+  const changeDir = positionals[1];
+  if (!subcommand || !changeDir) usage();
+
+  if (!['create', 'list', 'finish', 'resolve'].includes(subcommand)) {
+    console.error(`Unknown handoff subcommand: ${subcommand}. Valid: create, list, finish, resolve`);
+    process.exit(2);
+  }
+
+  if (subcommand === 'create') {
+    if (!hasText(values.type) || !hasText(values.objective)
+      || !hasText(values['expected-output']) || !hasText(values.acceptance)) {
+      usage('Usage: tf handoff create <change-dir> --type <type> --objective <text> --expected-output <text> --acceptance <text>');
+    }
+    if (!HANDOFF_TYPES.has(values.type)) {
+      throw new Error(`Unsupported handoff type '${values.type}'`);
+    }
+
+    const handoff = createHandoff(changeDir, {
+      type: values.type,
+      title: values.objective,
+      question: `Expected output: ${values['expected-output']}`,
+      context: `Acceptance: ${values.acceptance}`,
+      source: renderBoundaries(values.boundary),
+    });
+    output(values.json, { ok: true, handoff }, `Handoff created: ${handoff.id}`);
+    return;
+  }
+
+  if (subcommand === 'list') {
+    const handoffs = listHandoffs(changeDir);
+    output(values.json, { ok: true, handoffs }, handoffs.length === 0
+      ? 'No handoffs found.'
+      : handoffs.map(handoff => `${handoff.id}  type=${handoff.type}  status=${handoff.status}`).join('\n'));
+    return;
+  }
+
+  const id = positionals[2];
+  if (!hasText(id)) usage(`Usage: tf handoff ${subcommand} <change-dir> <id>${subcommand === 'resolve' ? ' --decision <accept|reject|defer>' : ''}`);
+
+  if (subcommand === 'finish') {
+    const handoff = finishHandoff(changeDir, id);
+    output(values.json, { ok: true, handoff }, `Handoff finished: ${handoff.id}`);
+    return;
+  }
+
+  if (!hasText(values.decision)) {
+    usage('Usage: tf handoff resolve <change-dir> <id> --decision <accept|reject|defer>');
+  }
+  if (!HANDOFF_DECISIONS.has(values.decision)) {
+    throw new Error(`Unsupported handoff decision '${values.decision}'`);
+  }
+
+  const handoff = resolveHandoff(changeDir, id, values.decision, values['acknowledge-source-drift']);
+  output(values.json, { ok: true, handoff }, `Handoff resolved: ${handoff.id} (${handoff.decision})`);
+}
+
+function hasText(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function renderBoundaries(boundaries) {
+  return boundaries?.length ? `Boundaries:\n${boundaries.map(boundary => `- ${boundary}`).join('\n')}` : 'Not recorded';
+}
+
+function output(json, payload, text) {
+  console.log(json ? JSON.stringify(payload) : text);
+}
+
+function usage(message = USAGE) {
+  console.error(message);
+  process.exit(2);
+}