@boyingliu01/xp-gate 0.19.3 → 0.20.1

package/lib/__tests__/doctor-tui-skill-freshness.test.js

@@ -0,0 +1,105 @@
+/**
+ * @test REQ-439
+ * @intent doctor 判技能新鲜度必须行尾无关：frontmatter 正则只认 LF + 退化分支做
+ *         字节比较，导致 autocrlf 工作树下 12/13 个技能被假报 Outdated，真差异
+ *         反而被噪声淹没（#439）
+ * @covers AC-439-01, AC-439-02, AC-439-03
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('doctor-tui skill freshness (#439)', () => {
+  let tmpHome;
+  let originalHome;
+  // Same dir doctor-tui resolves as PKG_DIR (path.dirname of lib/).
+  const bundledSkillsDir = path.join(__dirname, '..', '..', 'skills');
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-fresh-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../doctor-tui')];
+    delete require.cache[require.resolve('../shared-paths')];
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  // HOME has no platform marker, so detectPlatform() resolves to opencode.
+  function installSkill(name, content) {
+    const dir = path.join(tmpHome, '.config', 'opencode', 'skills', name);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), content);
+  }
+
+  function readBundled(name) {
+    return fs.readFileSync(path.join(bundledSkillsDir, name, 'SKILL.md'), 'utf8');
+  }
+
+  /** Same bytes, opposite line endings — the only difference a fresh install can have. */
+  function flipLineEndings(content) {
+    const lf = content.replace(/\r\n/g, '\n');
+    return lf === content ? lf.replace(/\n/g, '\r\n') : lf;
+  }
+
+  function runFreshness(name) {
+    const { diagnoseInstalledSkills } = require('../doctor-tui');
+    const checks = [];
+    const issues = diagnoseInstalledSkills({ installedSkills: { [name]: {} } }, checks);
+    const check = checks.find(c => c.name === `Skill: ${name}`);
+    return { issues, check };
+  }
+
+  it('reads a version from CRLF frontmatter, not only LF', () => {
+    const { extractSkillVersion } = require('../doctor-tui');
+    expect(extractSkillVersion('---\r\nname: x\r\nversion: 2.1.0\r\n---\r\nbody\r\n')).toBe('2.1.0');
+    // LF must keep working -- the fix is a widening, not a swap.
+    expect(extractSkillVersion('---\nname: x\nversion: 2.1.0\n---\nbody\n')).toBe('2.1.0');
+    // ... and so must a lone CR, the third convention the helper's name covers.
+    expect(extractSkillVersion('---\rname: x\rversion: 2.1.0\r---\rbody\r')).toBe('2.1.0');
+  });
+
+  it('treats a versioned skill as up to date when only line endings differ', () => {
+    const bundled = readBundled('sprint-flow');
+    expect(bundled).toMatch(/^---/);
+    installSkill('sprint-flow', flipLineEndings(bundled));
+    const { check } = runFreshness('sprint-flow');
+    expect(check, JSON.stringify(check)).toBeDefined();
+    expect(check.status).toBe('PASS');
+  });
+
+  it('treats a versionless skill as up to date when only line endings differ', () => {
+    const bundled = readBundled('grilling');
+    // This is the branch the issue hit for 11 of 12 skills: no version field at all,
+    // so freshness can only be decided by content.
+    expect(bundled).not.toMatch(/^version:/m);
+    installSkill('grilling', flipLineEndings(bundled));
+    const { check } = runFreshness('grilling');
+    expect(check, JSON.stringify(check)).toBeDefined();
+    expect(check.status).toBe('PASS');
+  });
+
+  // AC-439-02 promises "differences beyond line endings" still report Outdated,
+  // which means every line-ending convention has to be tolerated, not just CRLF
+  // (Round 2 feasibility FC-05: the helper's name already says as much).
+  it('treats a lone-CR skill file as up to date too', () => {
+    const bundled = readBundled('grilling');
+    installSkill('grilling', bundled.replace(/\r\n/g, '\n').replace(/\n/g, '\r'));
+    const { check } = runFreshness('grilling');
+    expect(check, JSON.stringify(check)).toBeDefined();
+    expect(check.status).toBe('PASS');
+  });
+
+  it('still reports Outdated for a real content difference (anti-vacuity)', () => {
+    const bundled = readBundled('grilling');
+    installSkill('grilling', `${flipLineEndings(bundled)}\n## Diverged section\n`);
+    const { issues, check } = runFreshness('grilling');
+    expect(check.status).toBe('WARN');
+    expect(check.detail).toContain('Outdated');
+    expect(issues).toBe(1);
+  });
+});

package/lib/__tests__/doctor.test.js

@@ -18,6 +18,7 @@ describe('doctor', () => {
   let tmpProject;
   let originalHome;
   let originalXpGateCacheDir;
+  let originalRepoRoot;
   let originalDetectDepsTools;
   let originalExecSync;
   let originalExec;
@@ -54,12 +55,19 @@ describe('doctor', () => {
   beforeEach(() => {
     originalHome = process.env.HOME;
     originalXpGateCacheDir = process.env.XP_GATE_CACHE_DIR;
+    originalRepoRoot = process.env.XP_GATE_REPO_ROOT;
     originalExecSync = cp.execSync;
     originalExec = cp.exec;
     // Unique per-describe + per-test prefixes to avoid parallel collisions.
     tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), `xpgate-dr-${DESCRIBE_ID}-`));
     tmpProject = fs.mkdtempSync(path.join(os.tmpdir(), `xpgate-dr-proj-${DESCRIBE_ID}-`));
     process.env.HOME = tmpHome;
+    // #451: the hook-drift check reads the canonical githooks/ of *this* repo
+    // when no override is given. In a fixture whose whole point is "a healthy
+    // installation", that would compare the real checkout against synthetic
+    // temp files and always report drift. Point it at an empty dir instead:
+    // these tests assert installation health, not drift.
+    process.env.XP_GATE_REPO_ROOT = path.join(tmpProject, 'no-repo-hooks');
     vi.resetModules();
     // Invalidate all cached modules that load path/environment globals at require-time.
     // Do NOT invalidate detect-deps.js — its GATE_CLI_TOOLS was already cleared in beforeAll
@@ -79,6 +87,8 @@ describe('doctor', () => {
   afterEach(() => {
     process.env.HOME = originalHome;
     process.env.XP_GATE_CACHE_DIR = originalXpGateCacheDir;
+    if (originalRepoRoot === undefined) delete process.env.XP_GATE_REPO_ROOT;
+    else process.env.XP_GATE_REPO_ROOT = originalRepoRoot;
     cp.execSync = originalExecSync;
     cp.exec = originalExec;
     if (tmpHome && fs.existsSync(tmpHome)) {
@@ -130,6 +140,14 @@ describe('doctor', () => {
     );
   }
 
+  function createXpGatePostMerge(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, 'post-merge'),
+      '#!/usr/bin/env bash\n# post-merge - XP-Gate VERSION sync hook\n'
+    );
+  }
+
   function createXpGateAdapterCommon(dir) {
     fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(
@@ -166,6 +184,7 @@ describe('doctor', () => {
   function setupLocalInstall() {
     createXpGatePreCommit(projectHooksDir());
     createXpGatePrePush(projectHooksDir());
+    createXpGatePostMerge(projectHooksDir());
     createXpGateAdapterCommon(projectGithooksDir());
     createXpGateAdapterScripts(projectGithooksDir());
 
@@ -182,6 +201,7 @@ describe('doctor', () => {
   function setupGlobalInstall() {
     createXpGatePreCommit(globalHooksDir());
     createXpGatePrePush(globalHooksDir());
+    createXpGatePostMerge(globalHooksDir());
     createXpGateAdapterCommon(globalAdaptersDir());
     // For global mode, create adapters directly in globalAdaptersDir (not in a subdirectory)
     fs.mkdirSync(globalAdaptersDir(), { recursive: true });
@@ -337,6 +357,21 @@ describe('doctor', () => {
     );
   });
 
+  it('AC-08: doctor detects a missing post-merge hook', async () => {
+    setupLocalInstall();
+    seedVersionCache();
+    fs.unlinkSync(path.join(projectHooksDir(), 'post-merge'));
+    mockExecSuccess();
+    const { doctor } = require('../doctor');
+
+    const result = await doctor([]);
+
+    expect(result).toBe(1);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining('post-merge')
+    );
+  });
+
   it('AC-08: doctor detects missing config file', async () => {
     // No config at all
     const { doctor } = require('../doctor');
@@ -463,6 +498,19 @@ describe('doctor', () => {
     expect(fs.existsSync(path.join(projectHooksDir(), 'pre-push'))).toBe(true);
   });
 
+  it('AC-10: doctor --fix restores a missing post-merge hook', async () => {
+    setupLocalInstall();
+    seedVersionCache();
+    fs.unlinkSync(path.join(projectHooksDir(), 'post-merge'));
+    mockExecSuccess();
+    const { doctor } = require('../doctor');
+
+    const result = await doctor(['--fix']);
+
+    expect(result).toBe(0);
+    expect(fs.existsSync(path.join(projectHooksDir(), 'post-merge'))).toBe(true);
+  });
+
   it('AC-10: doctor --fix reinstall adapters when mode is active and adapters missing', async () => {
     setupLocalInstall();
     seedVersionCache();
@@ -551,6 +599,23 @@ describe('doctor', () => {
 
   // === Edge cases ===
 
+  it('AC-488: doctor rejects unknown flags instead of silently ignoring them', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const { doctor } = require('../doctor');
+    const result = await doctor(['--syn-hooks', 'extra-arg']);
+    expect(result).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown flag'));
+    errorSpy.mockRestore();
+  });
+
+  it('AC-488: doctor still accepts its documented flags', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const { doctor } = require('../doctor');
+    await doctor(['--fix', '--sync-hooks']);
+    expect(errorSpy).not.toHaveBeenCalled();
+    errorSpy.mockRestore();
+  });
+
   it('reports exit code 1 with unhealthy or missing install', async () => {
     const { doctor } = require('../doctor');
     const result = await doctor([]);
@@ -1053,4 +1118,94 @@ describe('doctor', () => {
     expect(json.ok).toBe(true);
     expect(json.issues).toBe(0);
   });
+
+  // AC-488-08: the flag was advertised in the release notes since the version
+  // that added doctor, and rejected as an unknown flag until now. Asserting the
+  // FORMATTER alone would pass while `doctor --format json` still crashed, so
+  // this runs the command and inspects what a script would actually parse.
+  it('AC-488-08: doctor --format json emits one parseable document and nothing else', async () => {
+    setupLocalInstall();
+    seedVersionCache();
+    mockExecSuccess();
+    const { doctor } = require('../doctor');
+    const seen = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((msg) => { seen.push(String(msg)); });
+
+    let code;
+    try {
+      code = await doctor(['--format', 'json']);
+    } finally {
+      logSpy.mockRestore();
+    }
+
+    expect(seen, `expected exactly one JSON line, got:\n${seen.join('\n')}`).toHaveLength(1);
+    const doc = JSON.parse(seen[0]);
+    expect(doc.ok).toBe(code === 0);
+    expect(Array.isArray(doc.checks)).toBe(true);
+    expect(doc.checks.length).toBeGreaterThan(0);
+    expect(seen[0]).not.toMatch(/XP-Gate Doctor|Diagnosis Report/);
+  });
+
+  it('AC-488-08: a machine-readable doctor run cannot also mutate the machine', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const { doctor } = require('../doctor');
+
+    expect(await doctor(['--format', 'json', '--fix'])).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('--fix'));
+    expect(await doctor(['--json', '--sync-hooks'])).toBe(1);
+    errorSpy.mockRestore();
+  });
+
+  it('AC-488-08: an unknown --format value is rejected instead of silently ignored', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const { doctor } = require('../doctor');
+
+    expect(await doctor(['--format', 'yaml'])).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('--format'));
+    errorSpy.mockRestore();
+  });
+
+  // AC-488-09 (#488 Round 4, feasibility): the same class as the original issue —
+  // a flag that is accepted and then does nothing. `--format` with no value, and
+  // `--force` with no mode that reads it, both looked like they ran.
+  it('AC-488-09: a value-less --format is rejected instead of silently dropping the flag', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const { doctor } = require('../doctor');
+
+    expect(await doctor(['--format'])).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('--format'));
+    errorSpy.mockRestore();
+  });
+
+  it('AC-488-09: --force is refused when no mode consumes it', () => {
+    // Asserted through the pure contract rather than by running the command:
+    // the only mode that reads --force is the one that copies files over the
+    // installed hooks, so a run-based assertion would mutate this machine.
+    const { doctorFlagContract } = require('../doctor');
+
+    const bare = doctorFlagContract(['--force']);
+    expect(bare.errors).toHaveLength(2);
+    expect(bare.errors[0]).toContain('--force');
+    expect(bare.errors[0]).toContain('--sync-hooks');
+    expect(doctorFlagContract(['--fix', '--force']).errors.length, '--fix does not read --force either').toBeGreaterThan(0);
+
+    const synced = doctorFlagContract(['--sync-hooks', '--force']);
+    expect(synced.errors, synced.errors.join('\n')).toHaveLength(0);
+    expect(synced.force).toBe(true);
+    expect(synced.syncHooks).toBe(true);
+  });
+
+  it('AC-488-09: --install-tools is refused unless --fix is the mode that reads it', () => {
+    const { doctorFlagContract } = require('../doctor');
+
+    const bare = doctorFlagContract(['--install-tools']);
+    expect(bare.errors).toHaveLength(2);
+    expect(bare.errors[0]).toContain('--install-tools');
+    expect(bare.errors[0]).toContain('--fix');
+    expect(doctorFlagContract(['--sync-hooks', '--install-tools']).errors.length).toBeGreaterThan(0);
+
+    const fixing = doctorFlagContract(['--fix', '--install-tools']);
+    expect(fixing.errors, fixing.errors.join('\n')).toHaveLength(0);
+    expect(fixing.installToolsFlag).toBe(true);
+  });
 });

package/lib/__tests__/gate-runner.test.js

@@ -43,6 +43,17 @@ function shellParameter(expression) {
   return ['$', '{', expression, '}'].join('');
 }
 
+// Path segment that must survive quoting untouched. Windows rejects `"` and `*`
+// in a filename, so the hostile set there keeps the same bash hazards — word
+// split, parameter expansion, command substitution, quoting, list separator —
+// with legal characters instead (#428).
+function hostilePathSegment() {
+  if (process.platform === 'win32') {
+    return "space $HOME `marker` 'quoted' & (paren)";
+  }
+  return 'space $HOME `marker` "quoted"';
+}
+
 function initializeGitProject() {
   execFileSync('git', ['init', '-q'], { cwd: tmpProject });
   execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd: tmpProject });
@@ -171,20 +182,25 @@ describe('gate-runner.js — runGateAdapter', () => {
       path.join(callerProject, 'githooks', 'gates', 'gate-9-caller.sh'),
       'echo "__CALLER_REPO__"\n'
     );
+    // The fragment is written into the target project only, so a relative probe
+    // answers "which project did we run in?" without comparing path strings —
+    // bash reports $PWD in POSIX form, which can never equal the Windows path
+    // the test passes as an argument (#428).
     fs.writeFileSync(
       path.join(targetProject, 'githooks', 'gates', 'gate-9-target.sh'),
       [
-        'if [ "$PWD" != "$EXPECTED_TARGET" ]; then exit 88; fi',
+        'if [ ! -f "githooks/gates/gate-9-target.sh" ]; then exit 88; fi',
+        'if [ -f ".xpgate-caller-only" ]; then exit 88; fi',
         'echo "__TARGET_REPO__"',
       ].join('\n')
     );
+    fs.writeFileSync(path.join(callerProject, '.xpgate-caller-only'), 'caller\n');
 
     const result = spawnSync(
       process.execPath,
       [path.join(packageFixture, 'bin', 'xp-gate.js'), 'check', '9', targetProject],
       {
         cwd: callerProject,
-        env: { ...process.env, EXPECTED_TARGET: targetProject },
         encoding: 'utf8',
         timeout: 30000,
       }
@@ -197,7 +213,7 @@ describe('gate-runner.js — runGateAdapter', () => {
 
   it('sources fragment and helper paths containing shell metacharacters literally (REQ-standalone-gates-07)', () => {
     const runnerAbsPath = path.resolve(__dirname, '../gate-runner.js');
-    const hostileRoot = path.join(tmpProject, 'space $HOME `marker` "quoted"');
+    const hostileRoot = path.join(tmpProject, hostilePathSegment());
     tmpAdapters = path.join(hostileRoot, 'githooks', 'adapters');
     fs.mkdirSync(tmpAdapters, { recursive: true });
     writeAdapterCommon();

package/lib/__tests__/helpers/lib-sandbox.cjs

@@ -0,0 +1,55 @@
+/**
+ * Shared scaffolding for `lib/__tests__` suites. Hoisted out of the #417 agent
+ * test because the same reset-and-mute sequence already lives in two other
+ * suites and a third inline copy tripped the architecture ratchet.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+/**
+ * Drop the HOME-derived modules from Node's cache so the next require() sees
+ * the sandboxed `process.env.HOME`.
+ *
+ * @param {object} vi - Vitest API
+ * @param {string[]} resolvedPaths - already require.resolve()d module paths
+ */
+function resetLibModules(vi, resolvedPaths) {
+  vi.resetModules();
+  for (const resolved of resolvedPaths) delete require.cache[resolved];
+}
+
+/**
+ * @param {object} vi - Vitest API
+ * @returns {{log: object, warn: object, error: object}} console spies
+ */
+function muteConsole(vi) {
+  const spies = {};
+  for (const level of ['log', 'warn', 'error']) {
+    spies[level] = vi.spyOn(console, level).mockImplementation(() => {});
+  }
+  return spies;
+}
+
+/**
+ * @param {string[]} prefixes - tmpdir name prefixes to create
+ * @returns {Object<string, string>} created temp directories by prefix
+ */
+function makeTempDirs(prefixes) {
+  const dirs = {};
+  for (const prefix of prefixes) {
+    dirs[prefix] = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
+  }
+  return dirs;
+}
+
+/**
+ * @param {Object<string, string>} dirs - directories returned by makeTempDirs
+ */
+function removeTempDirs(dirs) {
+  for (const dir of Object.values(dirs)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+module.exports = { resetLibModules, muteConsole, makeTempDirs, removeTempDirs };

package/lib/__tests__/init.test.js

@@ -385,28 +385,35 @@ describe('init', () => {
       return path.join(__dirname, '..', '..', 'plugins', 'qoder', 'agents');
     }
 
-    it('deploys Delphi agents when platform is Qoder and agents do not exist', async () => {
-      fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
-      mockExecSuccess();
-      setupQoderPlatform();
-
-      // Ensure agent templates exist in the npm package
+    // Real agent templates ship inside the git-tracked mirror
+    // (src/npm-package/plugins/qoder/agents/) — tests must never write there.
+    function assertRealTemplatePresent() {
       const templateDir = agentTemplateDir();
-      fs.mkdirSync(templateDir, { recursive: true });
-      fs.writeFileSync(path.join(templateDir, 'delphi-architecture.md'), '---\nname: test\n---\narch expert');
+      expect(fs.existsSync(path.join(templateDir, 'delphi-architecture.md'))).toBe(true);
+    }
 
+    // Fresh module registry so init() picks up this test's tmpProject/tmpHome.
+    function reloadInit() {
       vi.resetModules();
       delete require.cache[require.resolve('../init')];
       delete require.cache[require.resolve('../detect-deps.js')];
       delete require.cache[require.resolve('../shared-paths')];
+      return require('../init');
+    }
 
-      const { init } = require('../init');
+    it('deploys Delphi agents when platform is Qoder and agents do not exist', async () => {
+      fs.mkdirSync(path.join(tmpProject, '.git', 'hooks'), { recursive: true });
+      mockExecSuccess();
+      setupQoderPlatform();
+      assertRealTemplatePresent();
+
+      const { init } = reloadInit();
       const result = await init(['--core-only']);
       expect(result).toBe(0);
 
       const deployedAgent = path.join(tmpProject, '.qoder', 'agents', 'delphi-architecture.md');
       expect(fs.existsSync(deployedAgent)).toBe(true);
-      expect(fs.readFileSync(deployedAgent, 'utf8')).toContain('arch expert');
+      expect(fs.readFileSync(deployedAgent, 'utf8')).toContain('name: delphi-architecture');
     });
 
     it('does not overwrite existing agent files (preserves user customizations)', async () => {
@@ -419,10 +426,18 @@ describe('init', () => {
       fs.mkdirSync(agentsDir, { recursive: true });
       fs.writeFileSync(path.join(agentsDir, 'delphi-architecture.md'), 'CUSTOM USER CONTENT');
 
-      // Template in npm package
-      const templateDir = agentTemplateDir();
-      fs.mkdirSync(templateDir, { recursive: true });
-      fs.writeFileSync(path.join(templateDir, 'delphi-architecture.md'), 'TEMPLATE CONTENT');
+      assertRealTemplatePresent();
+
+      const { init } = reloadInit();
+      await init(['--core-only']);
+
+      // User content preserved
+      expect(fs.readFileSync(path.join(agentsDir, 'delphi-architecture.md'), 'utf8')).toBe('CUSTOM USER CONTENT');
+    });
+
+    it('deploys Delphi agents to the user-level agents dir in global mode', async () => {
+      mockExecSuccess();
+      setupQoderPlatform();
 
       vi.resetModules();
       delete require.cache[require.resolve('../init')];
@@ -430,10 +445,22 @@ describe('init', () => {
       delete require.cache[require.resolve('../shared-paths')];
 
       const { init } = require('../init');
-      await init(['--core-only']);
+      const result = await init(['--global']);
+      expect(result).toBe(0);
 
-      // User content preserved
-      expect(fs.readFileSync(path.join(agentsDir, 'delphi-architecture.md'), 'utf8')).toBe('CUSTOM USER CONTENT');
+      const globalAgent = path.join(tmpHome, '.qoder', 'agents', 'delphi-architecture.md');
+      expect(fs.existsSync(globalAgent)).toBe(true);
+    });
+
+    it('pins every expert template to a distinct built-in model in "[Name](modelId)" form', () => {
+      const templateDir = agentTemplateDir();
+      const { readQoderModelId } = require('../init');
+      const models = ['delphi-architecture', 'delphi-technical', 'delphi-feasibility'].map(name => {
+        const modelId = readQoderModelId(path.join(templateDir, `${name}.md`));
+        expect(modelId).not.toBeNull();
+        return modelId;
+      });
+      expect(new Set(models).size).toBe(3);
     });
 
     it('skips deployment when platform is not Qoder', async () => {