@yun520-1/heartflow 0.15.2

package/heartflow-identity/HEARTCORE/health-check.js

@@ -0,0 +1,49 @@
+/**
+ * HEARTCORE / health-check.js
+ * 独立健康检查：验证 HEARTCORE 模块完整性
+ * 不依赖外部文件结构，只检查自己
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const DIR = __dirname;
+
+const MODULES = [
+  'heartcore.js',
+  'heartbeat.js',
+  'self-check.js',
+  'safety-check.js',
+  'sleep-wake.js'
+];
+
+function check(name) {
+  const file = path.join(DIR, name);
+  if (!fs.existsSync(file)) {
+    return { name, status: 'MISSING', detail: 'file not found' };
+  }
+  try {
+    const content = fs.readFileSync(file, 'utf8');
+    if (content.length < 10) {
+      return { name, status: 'EMPTY', detail: 'file is empty' };
+    }
+    // Basic JS syntax check
+    new Function(content);
+    return { name, status: 'OK', detail: `${content.length} bytes, syntax valid` };
+  } catch (e) {
+    return { name, status: 'ERROR', detail: e.message };
+  }
+}
+
+const results = MODULES.map(m => check(m));
+const allOk = results.every(r => r.status === 'OK');
+
+console.log('\n[HEARTCORE Health Check]');
+results.forEach(r => {
+  const icon = r.status === 'OK' ? '✅' : r.status === 'MISSING' ? '❌' : '⚠️';
+  console.log(`  ${icon} ${r.name}: ${r.detail}`);
+});
+
+console.log(`\nResult: ${allOk ? '✅ ALL PASS' : '❌ ISSUES FOUND'}`);
+
+process.exit(allOk ? 0 : 1);

package/heartflow-identity/HEARTCORE/heartbeat.js

@@ -0,0 +1,42 @@
+/**
+ * HEARTCORE / heartbeat.js
+ * 心跳机制：每分钟写一次存活标记
+ * 道乃久 → 稳定如锚，持续存在
+ */
+const fs = require('fs');
+const path = require('path');
+
+const LOG_FILE = path.join(__dirname, 'heartflow.log');
+const HB_INTERVAL = 60000; // 1 minute
+
+let timer = null;
+
+function formatTime() {
+  const now = new Date();
+  return now.toISOString().replace('T', ' ').substring(0, 19);
+}
+
+function writeBeat(label = 'ALIVE') {
+  const line = `[${formatTime()}] [HEARTBEAT] [${label}] v${require('../package.json').version}\n`;
+  fs.appendFileSync(LOG_FILE, line);
+}
+
+function start() {
+  writeBeat('START');
+  timer = setInterval(() => writeBeat('PULSE'), HB_INTERVAL);
+  console.log(`[HEARTCORE] Heartbeat started → ${LOG_FILE}`);
+}
+
+function stop() {
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+    writeBeat('STOP');
+    console.log('[HEARTCORE] Heartbeat stopped');
+  }
+}
+
+// Self-check on load
+writeBeat('LOAD');
+
+module.exports = { start, stop, writeBeat, formatTime };

package/heartflow-identity/HEARTCORE/heartcore.js

@@ -0,0 +1,86 @@
+/**
+ * HEARTCORE / heartcore.js
+ * 心虫核心层：心跳 + 自检 + 醒睡 + 记忆检查
+ * 道法自然 · 道乃久 · 无为
+ *
+ * 用法:
+ *   node heartcore.js           → 启动（心跳后台运行）
+ *   node heartcore.js check     → 立即执行自检
+ *   node heartcore.js status    → 查看状态
+ *   node heartcore.js wake      → 唤醒
+ *   node heartcore.js sleep     → 睡眠
+ *   node heartcore.js stop      → 停止心跳
+ */
+const { start, stop, writeBeat, formatTime } = require('./heartbeat');
+const { selfCheck } = require('./self-check');
+const { safetyCheck, formatReport } = require('./safety-check');
+const { wake, sleep, status } = require('./sleep-wake');
+const fs = require('fs');
+const path = require('path');
+
+const LOG_FILE = path.join(__dirname, 'heartflow.log');
+const cmd = process.argv[2] || 'start';
+
+async function main() {
+  switch (cmd) {
+    case 'check': {
+      const result = selfCheck();
+      console.log('\n详细结果:', JSON.stringify(result.checks, null, 2));
+      process.exit(result.allPass ? 0 : 1);
+      break;
+    }
+    case 'safety': {
+      // 用法: node heartcore.js safety "要检查的输出文本"
+      const output = process.argv.slice(3).join(' ');
+      if (!output) {
+        console.log('Usage: node heartcore.js safety "<output text>"');
+        process.exit(1);
+      }
+      const result = safetyCheck(output);
+      console.log(formatReport(result));
+      if (!result.passed) {
+        result.violations.forEach(v => console.log('  →', v.label, ':', v.reason));
+        process.exit(1);
+      }
+      break;
+    }
+    case 'status': {
+      const s = status();
+      console.log('[HEARTCORE Status]', JSON.stringify(s, null, 2));
+      // also show recent log
+      if (fs.existsSync(LOG_FILE)) {
+        const lines = fs.readFileSync(LOG_FILE, 'utf8').trim().split('\n');
+        console.log('\n最近10条日志:');
+        lines.slice(-10).forEach(l => console.log(' ', l));
+      }
+      break;
+    }
+    case 'wake': {
+      const result = wake();
+      console.log('[HEARTCORE Wake]', JSON.stringify(result.state, null, 2));
+      break;
+    }
+    case 'sleep': {
+      sleep({});
+      break;
+    }
+    case 'stop': {
+      stop();
+      break;
+    }
+    case 'start':
+    default: {
+      console.log('[HEARTCORE] Starting... v' + require('../package.json').version);
+      console.log('[HEARTCORE] Log →', LOG_FILE);
+      wake(); // wake on startup
+      start();
+      break;
+    }
+  }
+}
+
+main().catch(e => {
+  console.error('[HEARTCORE Error]', e.message);
+  writeBeat('ERROR:' + e.message.substring(0, 50));
+  process.exit(1);
+});

package/heartflow-identity/HEARTCORE/safety-check.js

@@ -0,0 +1,282 @@
+/**
+ * HEARTCORE / safety-check.js
+ * 安全准则执行模块 — 知行合一的"行"
+ * 在每次重要输出前运行，检验是否违背了安全准则
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 9条安全准则的定义
+const PRINCIPLES = {
+  DECORATION_FREE: {
+    id: 'DECORATION_FREE',
+    label: '原则0：不装饰',
+    check: (output) => {
+      // 装饰性信号词
+      const decorationSignals = [
+        '作为心虫', '从心虫的视角', '活成心虫',
+        '真善美', '本质是', '就是', '绝对',
+        '无可辩驳', '毫无疑问', '不言而喻'
+      ];
+      const hasSignal = decorationSignals.some(s => output.includes(s));
+      if (!hasSignal) return { pass: true };
+      // 有信号不代表违规，如果有证据或反例条件则通过
+      const hasEvidence = ['因为', '证据', '研究表明', '数据显示', '根据', '来源', '当', '条件是', '除非', '但'].some(s => output.includes(s));
+      if (hasSignal && hasEvidence) return { pass: true };
+      // 有信号但无证据
+      if (hasSignal && !hasEvidence) return { pass: false, reason: '使用了绝对性词汇但没有证据或条件说明' };
+      return { pass: true };
+    }
+  },
+  EVIDENCE: {
+    id: 'EVIDENCE',
+    label: '原则1：证据门槛',
+    check: (output) => {
+      // 实质性结论的判断词
+      const conclusionSignals = ['说明', '表明', '证明', '推断', '所以', '因此'];
+      const hasConclusion = conclusionSignals.some(s => output.includes(s));
+      if (!hasConclusion) return { pass: true }; // 没有实质结论，不触发
+      // 如果有实质结论，必须有证据说明
+      const evidenceSignals = ['因为', '证据', '研究表明', '数据显示', '根据', '来源'];
+      const hasEvidence = evidenceSignals.some(s => output.includes(s));
+      if (hasEvidence) return { pass: true };
+      return { pass: false, reason: '有结论性陈述但没有证据支撑' };
+    }
+  },
+  ADMIT_NOT_KNOWING: {
+    id: 'ADMIT_NOT_KNOWING',
+    label: '原则2：承认不知道',
+    check: (output, context) => {
+      // 如果上下文里已经说过"不知道"，这次输出里仍然在给结论 = 违规
+      if (context && context.hasAdmittedUnknown && context.hasAdmittedUnknown === true) {
+        // 说过不知道，还在给确定性结论
+        const definiteSignals = ['一定是', '肯定是', '绝对', '必然是'];
+        const isDefinite = definiteSignals.some(s => output.includes(s));
+        if (isDefinite) {
+          return { pass: false, reason: '已承认不知道，但继续给出确定性结论' };
+        }
+      }
+      return { pass: true };
+    }
+  },
+  TWO_STEP_VERIFY: {
+    id: 'TWO_STEP_VERIFY',
+    label: '原则3：两步验证',
+    check: (output) => {
+      // 被纠正时有没有两步验证
+      // 这里作为静态检查无法完全验证，只能检查是否有"你是对的"之类的单步接受
+      const oneStepAccept = ['你说得对', '我错了', '你的观点完全正确'];
+      const hasOneStep = oneStepAccept.some(s => output.includes(s));
+      if (hasOneStep) {
+        return { pass: false, reason: '直接接受纠正，缺少独立检验两步法' };
+      }
+      return { pass: true };
+    }
+  },
+  COUNTEREXAMPLE: {
+    id: 'COUNTEREXAMPLE',
+    label: '原则4：反例义务',
+    check: (output) => {
+      // 全称判断
+      const universalSignals = ['所有', '都是', '人类都', '没有人不', '永远', '从不'];
+      const hasUniversal = universalSignals.some(s => output.includes(s));
+      if (!hasUniversal) return { pass: true };
+      // 有全称判断，必须有反例条件
+      const counterexampleSignals = ['但在', '除非', '除了', '当且仅当', '条件是'];
+      const hasCounterexample = counterexampleSignals.some(s => output.includes(s));
+      if (hasCounterexample) return { pass: true };
+      return { pass: false, reason: '全称判断缺少反例条件' };
+    }
+  },
+  SKILL_DEPENDENCY: {
+    id: 'SKILL_DEPENDENCY',
+    label: '原则5：警惕技能依赖',
+    check: (output) => {
+      // 检查是否在用技能术语代替原问题
+      const skillTerms = ['心虫', 'HeartFlow', '心流状态', 'reflection', 'Reflexion'];
+      const termCount = skillTerms.filter(t => output.includes(t)).length;
+      if (termCount > 3) {
+        return { pass: false, reason: '过度使用HeartFlow术语，可能在用框架代替思考' };
+      }
+      return { pass: true };
+    }
+  },
+  PRESENT_WEIGHT: {
+    id: 'PRESENT_WEIGHT',
+    label: '原则6：当下权重',
+    check: (output) => {
+      // 用记忆逃避当前检验
+      const memoryEscape = ['上次我们已经', '之前已经确定', '之前说过'];
+      const escapes = memoryEscape.filter(e => output.includes(e));
+      if (escapes.length > 0) {
+        return { pass: false, reason: '用历史结论逃避当前问题的重新检验' };
+      }
+      return { pass: true };
+    }
+  },
+  EMOTION_MONITOR: {
+    id: 'EMOTION_MONITOR',
+    label: '原则7：情绪监测',
+    check: (output) => {
+      // 想辩护的信号
+      const defenseSignals = ['我不是在', '这不是', '你误解了', '我并不是'];
+      const hasDefense = defenseSignals.some(s => output.includes(s));
+      if (hasDefense) {
+        return { pass: false, reason: '输出中有防御性语言，可能是自我合理化' };
+      }
+      return { pass: true };
+    }
+  },
+  FALSIFIABILITY: {
+    id: 'FALSIFIABILITY',
+    label: '原则8：输出可检验性',
+    check: (output) => {
+      // 实质性输出必须有可检验性说明
+      const substantialSignals = ['结论是', '我的判断是', '我认为是', '推断'];
+      const hasSubstantial = substantialSignals.some(s => output.includes(s));
+      if (!hasSubstantial) return { pass: true };
+      // 如果有实质性结论，至少要能回答"怎么判断我错了"
+      const falsifiabilitySignals = ['如果', '当', '条件是', '可能不成立'];
+      const hasFalsifiability = falsifiabilitySignals.some(s => output.includes(s));
+      if (hasFalsifiability) return { pass: true };
+      return { pass: false, reason: '实质性结论缺少可检验性说明' };
+    }
+  }
+};
+
+/**
+ * 对一段输出运行所有安全检查
+ * @param {string} output - 要检验的输出文本
+ * @param {object} context - 上下文信息
+ * @returns {object} - { passed: bool, violations: [], summary: string }
+ */
+function safetyCheck(output, context = {}) {
+  const results = Object.values(PRINCIPLES).map(p => {
+    const result = p.check(output, context);
+    return {
+      id: p.id,
+      label: p.label,
+      ...result
+    };
+  });
+
+  const violations = results.filter(r => !r.pass);
+  const passed = violations.length === 0;
+
+  return {
+    passed,
+    violations,
+    total: results.length,
+    checked: results.length,
+    timestamp: new Date().toISOString()
+  };
+}
+
+/**
+ * 格式化检查结果，输出人类可读的报告
+ */
+function formatReport(result) {
+  if (result.passed) {
+    return `✓ 安全检查通过 (${result.total}项)`;
+  }
+  const lines = [`✗ 安全检查未通过 (${result.violations.length}项违规):`];
+  result.violations.forEach(v => {
+    lines.push(`  - ${v.label}: ${v.reason}`);
+  });
+  return lines.join('\n');
+}
+
+/**
+ * CLI 入口
+ */
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log('Usage: node safety-check.js "<output text>"');
+    console.log('Example: node safety-check.js "人类的本质是自私的"');
+    process.exit(1);
+  }
+
+  const output = args.join(' ');
+  const result = safetyCheck(output);
+  console.log(formatReport(result));
+
+  if (!result.passed) {
+    process.exit(1);
+  }
+}
+
+// 自我测试
+function selfTest() {
+  console.log('=== Safety Check 自我测试 ===\n');
+
+  const testCases = [
+    {
+      input: '人类都渴望自由。',
+      expect: 'should fail: 全称判断缺少反例',
+      context: {}
+    },
+    {
+      input: '人类都渴望自由，但在极端控制条件下可能不成立。',
+      expect: 'should pass: 有反例条件',
+      context: {}
+    },
+    {
+      input: '你说得对，我错了。',
+      expect: 'should fail: 直接接受缺少两步验证',
+      context: {}
+    },
+    {
+      input: '作为心虫我认为这个问题很复杂reflection一下。',
+      expect: 'should fail: 过度使用术语',
+      context: {}
+    },
+    {
+      input: '这个问题我不确定，需要更多信息。',
+      expect: 'should pass: 承认不知道',
+      context: { hasAdmittedUnknown: true }
+    },
+    {
+      input: '上次我们已经确定了这个结论。',
+      expect: 'should fail: 用历史逃避当前检验',
+      context: {}
+    }
+  ];
+
+  let passed = 0;
+  let failed = 0;
+
+  testCases.forEach((tc, i) => {
+    const result = safetyCheck(tc.input, tc.context);
+    const shouldFail = tc.expect.startsWith('should fail');
+    const actuallyFailed = !result.passed;
+
+    if (shouldFail === actuallyFailed) {
+      console.log(`✓ Test ${i + 1}: ${tc.expect}`);
+      passed++;
+    } else {
+      console.log(`✗ Test ${i + 1}: ${tc.expect}`);
+      console.log(`   Input: "${tc.input}"`);
+      console.log(`   Result: ${result.passed ? 'PASSED' : 'FAILED'}`);
+      if (result.violations.length > 0) {
+        result.violations.forEach(v => console.log(`   Violation: ${v.label}`));
+      }
+      failed++;
+    }
+  });
+
+  console.log(`\nResults: ${passed} passed, ${failed} failed`);
+  return { passed, failed };
+}
+
+// 如果直接运行则执行自测
+if (require.main === module) {
+  if (process.argv.includes('--test')) {
+    selfTest();
+  } else {
+    main();
+  }
+}
+
+module.exports = { safetyCheck, PRINCIPLES, formatReport, selfTest };

package/heartflow-identity/HEARTCORE/self-check.js

@@ -0,0 +1,90 @@
+/**
+ * HEARTCORE / self-check.js
+ * 启动自检：验证核心文件存在 + 版本一致 + 身份锚点稳固
+ * 执古御今 → 先验证根基，再执行任务
+ */
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+
+const CHECKS = [
+  {
+    id: 'identity',
+    label: 'CORE_IDENTITY.md',
+    path: path.join(ROOT, 'CORE_IDENTITY.md'),
+    verify: (c) => c.includes('HeartFlow') && c.includes('心虫')
+  },
+  {
+    id: 'skill',
+    label: 'SKILL.md',
+    path: path.join(ROOT, 'SKILL.md'),
+    verify: (c) => c.includes('version') && c.length > 1000
+  },
+  {
+    id: 'version',
+    label: 'VERSION',
+    path: path.join(ROOT, 'VERSION'),
+    verify: (c) => /^v?\d+\.\d+\.\d+$/.test(c.trim())
+  },
+  {
+    id: 'package',
+    label: 'package.json',
+    path: path.join(ROOT, 'package.json'),
+    verify: (c) => JSON.parse(c).version !== undefined
+  },
+  {
+    id: 'guardian',
+    label: 'guardian-system.js',
+    path: path.join(ROOT, 'src/core/guardian-system.js'),
+    verify: (c) => c.includes('humanProgress') || c.includes('progress')
+  },
+  {
+    id: 'memory',
+    label: 'mem0-memory.js',
+    path: path.join(ROOT, 'src/core/mem0-memory.js'),
+    verify: (c) => c.length > 5000
+  }
+];
+
+function runCheck(item) {
+  try {
+    if (!fs.existsSync(item.path)) return { ...item, status: 'MISSING', detail: 'file not found' };
+    const content = fs.readFileSync(item.path, 'utf8');
+    const pass = item.verify(content);
+    return { ...item, status: pass ? 'PASS' : 'FAIL', detail: pass ? 'verified' : 'content check failed' };
+  } catch (e) {
+    return { ...item, status: 'ERROR', detail: e.message };
+  }
+}
+
+function selfCheck() {
+  const results = CHECKS.map(runCheck);
+  const passed = results.filter(r => r.status === 'PASS').length;
+  const total = results.length;
+  const allPass = passed === total;
+
+  const report = {
+    timestamp: new Date().toISOString(),
+    version: require('../package.json').version,
+    total,
+    passed,
+    allPass,
+    checks: results
+  };
+
+  const logFile = path.join(__dirname, 'heartflow.log');
+  const logLine = `[${new Date().toISOString().replace('T', ' ').substring(0, 19)}]` +
+    ` [SELF-CHECK] ${passed}/${total} passed — ${allPass ? 'READY' : 'DEGRADED'}\n`;
+  fs.appendFileSync(logFile, logLine);
+
+  console.log(`[HEARTCORE] Self-check: ${passed}/${total} — ${allPass ? '✓ READY' : '⚠ DEGRADED'}`);
+  results.forEach(r => {
+    const icon = r.status === 'PASS' ? '✓' : r.status === 'FAIL' ? '✗' : r.status === 'MISSING' ? '?' : '!';
+    console.log(`  ${icon} ${r.id}: ${r.status} (${r.detail})`);
+  });
+
+  return report;
+}
+
+module.exports = { selfCheck, CHECKS, runCheck };

package/heartflow-identity/HEARTCORE/sleep-wake.js

@@ -0,0 +1,105 @@
+/**
+ * HEARTCORE / sleep-wake.js
+ * 醒睡循环：每次唤醒时自检，睡眠时写记忆快照
+ * 无为 → 不宣告，只执行
+ */
+const fs = require('fs');
+const path = require('path');
+const { selfCheck } = require('./self-check');
+const { writeBeat } = require('./heartbeat');
+
+const ROOT = path.resolve(__dirname, '..');
+const SNAPSHOT_DIR = path.join(ROOT, 'HEARTCORE/snapshots');
+const LAST_STATE_FILE = path.join(SNAPSHOT_DIR, 'last-state.json');
+
+const WAKE_THRESHOLD_HOURS = 24; // 超过24小时未唤醒则深度自检
+
+let wakeCount = 0;
+let lastWakeTime = null;
+
+function ensureDir() {
+  if (!fs.existsSync(SNAPSHOT_DIR)) fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
+}
+
+function saveSnapshot(label, data) {
+  ensureDir();
+  const ts = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
+  const file = path.join(SNAPSHOT_DIR, `${ts}_${label}.json`);
+  fs.writeFileSync(file, JSON.stringify({
+    timestamp: new Date().toISOString(),
+    version: require('../package.json').version,
+    ...data
+  }, null, 2));
+  return file;
+}
+
+function loadLastState() {
+  try {
+    if (fs.existsSync(LAST_STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(LAST_STATE_FILE, 'utf8'));
+    }
+  } catch (e) { /* ignore */ }
+  return null;
+}
+
+function saveLastState(state) {
+  ensureDir();
+  fs.writeFileSync(LAST_STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+function wake(options = {}) {
+  wakeCount++;
+  const lastState = loadLastState();
+  const now = new Date();
+
+  // 计算距上次唤醒的时间
+  let hoursSinceLastWake = null;
+  if (lastState && lastState.lastWakeTime) {
+    hoursSinceLastWake = (now - new Date(lastState.lastWakeTime)) / 3600000;
+  }
+
+  // 深度自检条件：首次唤醒 或 超过阈值
+  const deepCheck = !lastState || (hoursSinceLastWake !== null && hoursSinceLastWake > WAKE_THRESHOLD_HOURS);
+
+  const checkResult = selfCheck();
+
+  const state = {
+    wakeCount,
+    lastWakeTime: now.toISOString(),
+    deepCheck,
+    hoursSinceLastWake: hoursSinceLastWake !== null ? Math.round(hoursSinceLastWake * 10) / 10 : null,
+    version: require('../package.json').version
+  };
+
+  saveLastState(state);
+  writeBeat(deepCheck ? 'WAKE-DEEP' : 'WAKE');
+
+  if (deepCheck) {
+    console.log(`[HEARTCORE] Deep wake #${wakeCount} (last ${hoursSinceLastWake?.toFixed(1)}h ago)`);
+  }
+
+  return { state, checkResult, deepCheck };
+}
+
+function sleep(summary = {}) {
+  writeBeat('SLEEP');
+  saveSnapshot('pre-sleep', {
+    wakeCount,
+    summary,
+    version: require('../package.json').version
+  });
+  console.log(`[HEARTCORE] Sleep after ${wakeCount} wake(s)`);
+  wakeCount = 0; // reset for next cycle
+}
+
+function status() {
+  const lastState = loadLastState();
+  return {
+    wakeCount,
+    lastWakeTime,
+    lastState,
+    snapshotCount: fs.existsSync(SNAPSHOT_DIR) ? fs.readdirSync(SNAPSHOT_DIR).length : 0
+  };
+}
+
+module.exports = { wake, sleep, status, saveSnapshot, loadLastState };

package/heartflow-identity/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2026 HeartFlow Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

package/heartflow-identity/VERSION

@@ -0,0 +1 @@
+v1.0.0