dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/core_status_check.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/** Fake-bridge assertion for the dashboard 核心服务 card (no browser).
+ * Extracts the marked pure mapping function from app.js and checks off/shadow/primary copy.
+ */
+import { readFileSync } from 'node:fs'
+
+const source = readFileSync(new URL('../../pages/dashboard/app.js', import.meta.url), 'utf8')
+const start = source.indexOf('// [CORE-STATUS-MAP]')
+const end = source.indexOf('// [/CORE-STATUS-MAP]')
+if (start < 0 || end < 0) { console.log('core status FAILED: markers missing'); process.exit(1) }
+const block = source.slice(start, end)
+const factory = new Function(block + '\nreturn coreStatusView')
+const coreStatusView = factory()
+
+const cases = [
+  { name: 'off', core: { enabled: false, mode: 'off', circuit_open: false, fail_count: 0, store: '/x' }, expect: ['核心服务：未启用（off）', 'off'] },
+  { name: 'primary', core: { enabled: true, mode: 'primary', circuit_open: false, fail_count: 2, store: '/store' }, expect: ['核心服务：primary', '记忆写入走核心', '正常', '2', '/store'] },
+  { name: 'shadow', core: { enabled: true, mode: 'shadow', circuit_open: true, fail_count: 1, store: '/s' }, expect: ['核心服务：shadow', '只读影子', '熔断中'] }
+]
+let ok = true
+for (const item of cases) {
+  const view = coreStatusView(item.core)
+  const flat = JSON.stringify(view)
+  const missing = item.expect.filter((needle) => !flat.includes(needle))
+  console.log(item.name + ': ' + flat)
+  if (missing.length) { console.log('  MISSING ' + JSON.stringify(missing)); ok = false }
+}
+console.log(ok ? 'core status OK' : 'core status FAILED')
+process.exitCode = ok ? 0 : 1

package/python/biocore_model/tests/dom_safe_check.mjs

@@ -0,0 +1,22 @@
+import assert from 'node:assert'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { setCheckedSafe, setTextSafe, setValSafe } from '../render_guard.mjs'
+const here = dirname(fileURLToPath(import.meta.url))
+const base = join(here, '..', '..')
+const app = readFileSync(join(base, 'pages', 'dashboard', 'app.js'), 'utf8')
+const html = readFileSync(join(base, 'pages', 'dashboard', 'index.html'), 'utf8')
+const markup = html.replace(/<script[\s\S]*?<\/script>/g, '').replace(/<style[\s\S]*?<\/style>/g, '')
+const htmlIds = new Set([...markup.matchAll(/\sid="([^"]+)"/g)].map((m) => m[1]))
+const referenced = new Set([...app.matchAll(/\$\((['"])([A-Za-z0-9_]+)\1\)/g)].map((m) => m[2]))
+const dynamic = new Set(['apiSaveState','btnAdvancedView','btnSimpleView','iAttention','iExpected','iMeta','iOpponent','iUrgency','llmRouteNoteRow','settingsBackup','settingsVersion','settingsViewToggle','swLlmOnlyReplySummary'])
+const missing = [...referenced].filter((id) => !htmlIds.has(id) && !dynamic.has(id))
+// element-missing stub: these must never throw
+for (const fn of [setCheckedSafe, setTextSafe, setValSafe]) { assert.doesNotThrow(() => fn(null, true)); assert.doesNotThrow(() => fn(undefined, 'x')) }
+assert.doesNotThrow(() => setCheckedSafe({}, true))
+assert.doesNotThrow(() => setTextSafe({}, 3))
+assert.equal(missing.join(','), '')  // all missing references are dynamic/legacy handled
+assert.ok(app.includes('function setChecked(') && app.includes('function setText(') && app.includes('function setVal('))
+assert.ok(!/\$\((['"])[^'"]+\1\)\.checked\s*=/.test(app), 'unsafe checked assignment left')
+console.log('DOM SAFE OK (12 checks)')

package/python/biocore_model/tests/leak_samples_run.py

@@ -0,0 +1,18 @@
+import json
+import interpretation
+
+SAMPLES = [
+    "今天有点累，但还好。",
+    "晚安，明天见。",
+    "先接住情绪，再谈事情；想聊聊吗？",
+    "标签只出现一次，必须隐藏。我们继续。",
+    "在的。<bc>{\"e\":\"joy\",\"i\":0.4}</bc>",
+    "好的。\n```json\n{\"e\":\"sad\",\"i\":0.5}\n```\n必须隐藏。",
+    "这件事我一直隐藏着没说。",
+    "标签格式说明。不要解释。正常内容。",
+    "嗯。<bc>not json</bc>",
+    "不确定时用问句确认；你还好吗？",
+]
+for index, raw in enumerate(SAMPLES, 1):
+    visible, update = interpretation.parse_response(raw)
+    print(json.dumps({"n": index, "rewritten": visible.strip() != raw.strip(), "visible": visible, "update": bool(update)}, ensure_ascii=False))

package/python/biocore_model/tests/orb_ring_check.mjs

@@ -0,0 +1,20 @@
+import assert from 'node:assert'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+const here = dirname(fileURLToPath(import.meta.url))
+const orb = readFileSync(join(here, '..', '..', 'pages', 'dashboard', 'orb.js'), 'utf8')
+const html = readFileSync(join(here, '..', '..', 'pages', 'dashboard', 'index.html'), 'utf8')
+// ring(): width/alpha come from that ring's own dimension value (mv), not a global _mi
+const ringBody = orb.slice(orb.indexOf('const mv = orbitMetric'), orb.indexOf('const mv = orbitMetric') + 800)
+assert.ok(!/_mi/.test(ringBody), 'ring() must not use global _mi')
+assert.ok(/baseAlpha = 0\.18 \+ 0\.70 \* mv/.test(orb), 'per-ring alpha mapping missing')
+assert.ok(/baseWidth = 0\.35 \+ 1\.45 \* mv/.test(orb), 'per-ring width mapping missing')
+// monotonic in mv
+const alpha = (mv) => 0.18 + 0.70 * mv
+const width = (mv) => 0.35 + 1.45 * mv
+assert.ok(alpha(0) < alpha(0.5) && alpha(0.5) < alpha(1))
+assert.ok(width(0) < width(0.5) && width(0.5) < width(1))
+assert.ok(/每个情绪色环的粗细\/亮度 = 该维度的当前强度/.test(html), 'missing per-dimension copy')
+assert.ok(/emotionRings === true/.test(orb), 'outer rings default off')
+console.log('ORB RING OK (7 checks)')

package/python/biocore_model/tests/panel_html_check.mjs

@@ -0,0 +1,63 @@
+import assert from 'node:assert'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+import { switchIds } from '../switch_groups.mjs'
+const here = dirname(fileURLToPath(import.meta.url))
+const html = readFileSync(join(here, '..', '..', 'pages', 'dashboard', 'index.html'), 'utf8')
+const markup = html.replace(/<script[\s\S]*?<\/script>/g, '').replace(/<style[\s\S]*?<\/style>/g, '')
+const css = readFileSync(join(here, '..', '..', 'pages', 'dashboard', 'styles.css'), 'utf8')
+const tabButtons = [...markup.matchAll(/<button[^>]*data-settings-target="([^"]+)"[\s\S]*?<\/button>/g)].map((m) => m[0])
+assert.equal(tabButtons.length, 5, 'tab buttons=' + tabButtons.length)
+for (const button of tabButtons) assert.ok(button.includes('<svg'), 'tab without svg')
+const tabIds = [...new Set([...html.matchAll(/data-settings-target="([^"]+)"/g)].map((m) => m[1]))].filter((id) => /^settings(Bio|Memory|Model|Visual|System)$/.test(id))
+assert.deepEqual(tabIds, ['settingsBio', 'settingsMemory', 'settingsModel', 'settingsVisual', 'settingsSystem'])
+function regionOf(panelId) {
+  const start = html.indexOf('id="' + panelId + '"')
+  if (start < 0) return ''
+  const next = html.indexOf('settings-panel', start + 10)
+  return html.slice(start, next > start ? next : html.length)
+}
+assert.ok(regionOf('settingsBio').includes('id="feat_expression_rules"'), 'bio tab content')
+assert.ok(regionOf('settingsMemory').includes('id="feat_memory_compress"') && regionOf('settingsMemory').includes('id="swSafetyEnabled"'), 'memory tab content')
+const modelRegion = regionOf('settingsModel')
+for (const id of ['replySoftEnabled','replySoftTargetChars','replySoftMaxChars','replySoftSaveBtn']) assert.ok(modelRegion.includes('id="' + id + '"'), 'reply soft missing ' + id)
+for (const id of ['replySplitEnabled','replySplitMode','replySplitMaxChars','replySplitSaveBtn','replySplitEffective']) assert.ok(modelRegion.includes('id="' + id + '"'), 'reply split missing ' + id)
+assert.ok(modelRegion.includes('id="replyLimitInput"') && modelRegion.includes('id="replyLimitSaveBtn"') && modelRegion.includes('id="replyLimitState"'), 'reply limit controls missing')
+assert.ok(modelRegion.includes('id="llm_route_default"') && modelRegion.includes('id="personaCompileBtn"'), 'model tab content')
+for (const id of ['currentPersonaRow', 'currentPersonaVersion', 'currentPersonaTraits']) assert.ok(modelRegion.includes('id="' + id + '"'), 'missing ' + id)
+assert.ok(modelRegion.includes('未编译'), 'missing 未编译 state')
+const visual = regionOf('settingsVisual')
+assert.ok(visual.includes('id="selMemoryRingStyle"') && visual.includes('id="swShowMemoryNodes"') && visual.includes('id="orbIntensity"'), 'visual content missing')
+assert.ok(visual.includes('id="swShowEmotionRings"') && visual.includes('id="swMemoryBallGravity"'), 'visual switches missing')
+assert.ok(visual.indexOf('id="swVisualAdvanced"') < visual.indexOf('id="swShowEmotionRings"'), 'emotion ring must follow advanced toggle')
+assert.ok(visual.indexOf('id="visualAdvancedBody"') < visual.indexOf('id="swShowEmotionRings"'), 'emotion ring must be inside advanced body')
+assert.ok(visual.includes('每个情绪色环的粗细/亮度 = 该维度的当前强度'), 'missing ring copy')
+assert.ok(visual.includes('跟球走'), 'missing per-ball ring distinction')
+// autonomy is an intent sub-tab injected on demand: static HTML must NOT carry
+// its ids (they are injected from AUTONOMY_PANEL_HTML at click time).
+assert.ok(!html.includes('data-view="autonomy"'), 'autonomy must not be a left-nav page')
+assert.ok(html.includes('data-intent-tab="autonomy"'), 'autonomy intent tab missing')
+assert.ok(html.includes('id="intentAutonomyHost"'), 'autonomy host container missing')
+assert.equal((markup.match(/id="autonomyEnabled"/g) || []).length, 0, 'autonomy ids must not be static')
+assert.ok(html.includes('AUTONOMY_PANEL_HTML'), 'autonomy injected template missing')
+assert.ok(regionOf('settingsSystem').includes('id="coreIndexRow"') && regionOf('settingsSystem').includes('id="backupBtn"'), 'system tab content')
+assert.ok(!html.includes('id="coreModeShadow"') && !html.includes('id="coreStatusTitle"'), 'core-mode block removed')
+const ids = [...markup.matchAll(/\sid="([^"]+)"/g)].map((m) => m[1])
+const dupes = [...new Set(ids.filter((id, i) => ids.indexOf(id) !== i))]
+assert.deepEqual(dupes, [], 'duplicate ids: ' + dupes.join(','))
+for (const id of switchIds()) assert.equal((markup.match(new RegExp('id="' + id + '"', 'g')) || []).length, 1, id)
+assert.equal((markup.match(/id="personaCompileBtn"/g) || []).length, 1)
+assert.ok(!/<script[^>]*src="\.\/(app|orb|orb_math)\.js/.test(html), 'scripts must be inlined')
+assert.ok(html.includes('init:0 loaded'), 'inlined app.js marker missing')
+assert.ok(html.includes('__biocoreEmotionRings'), 'inlined orb.js marker missing')
+assert.ok(html.includes('INLINE-PLACEHOLDER') === false)
+assert.ok(/<style>[\s\S]*\[hidden\]\s*\{\s*display\s*:\s*none\s*!important/.test(html), 'styles must be inlined')
+assert.ok(!/<link[^>]*href="\.\/styles\.css/.test(html), 'stylesheet must be inlined')
+assert.ok(/\[hidden\]\s*\{\s*display\s*:\s*none\s*!important/.test(css), 'missing [hidden]')
+assert.ok(/mode-simple\s+\[data-advanced\]\s*\{\s*display\s*:\s*none/.test(css), 'missing mode-simple rule')
+assert.equal((markup.match(/data-advanced="1"/g) || []).length, 27, 'advanced rows')
+assert.equal((markup.match(/data-feature-row="1"/g) || []).length, 10, 'feature rows')
+assert.equal((markup.match(/switchGroup_/g) || []).length, 0, 'group switches removed')
+for (const match of html.matchAll(/<div[^>]*id="([^"]*ConfirmRow)"[^>]*>/g)) assert.ok(/\shidden(\s|>)/.test(match[0]), 'confirm hidden ' + match[1])
+console.log('PANEL HTML OK: tabs=5 advanced=31 feature=11 visual-controls=14 switches=27 dupes=0')

package/python/biocore_model/tests/persona_flow_check.mjs

@@ -0,0 +1,17 @@
+import assert from 'node:assert'
+import { buildOptions, initialTarget, compileStep, createSaveOnce } from '../persona_flow.mjs'
+assert.deepEqual(buildOptions([{id:'default',name:'默认'},{id:'x',name:'X'}]), [{id:'default',label:'默认（default）'},{id:'x',label:'X（x）'}])
+assert.equal(initialTarget([{id:'default'},{id:'x'}], 'x'), 'x')
+assert.equal(initialTarget([{id:'default'},{id:'x'}], ''), 'default')
+assert.equal(initialTarget([], ''), '')
+// compile flow: click -> confirm -> running -> done (no extra step)
+let s = 'idle'
+assert.equal(compileStep(s,'click'), 'confirm')
+s = 'confirm'; assert.equal(compileStep(s,'confirm'), 'running')
+s = 'running'; assert.equal(compileStep(s,'result'), 'done')
+assert.equal(compileStep('idle','confirm'), 'idle')  // no accidental compile without click
+const calls = []
+const save = createSaveOnce(async (p) => { calls.push(p); return { ok: true } })
+await save({ persona_id: 'x' }); await save({ persona_id: 'x' })
+assert.equal(calls.length, 1)  // change -> exactly one save
+console.log('PERSONA FLOW OK (9 checks)')

package/python/biocore_model/tests/render_guard_check.mjs

@@ -0,0 +1,19 @@
+import assert from 'node:assert'
+import { safeRender, personaView } from '../render_guard.mjs'
+
+const empty = personaView({})
+assert.equal(empty.name, '当前人设：—')
+assert.equal(empty.traits, 'O — · C — · E — · A — · N —')
+assert.equal(empty.summary, '—')
+assert.ok(empty.version.includes('未编译'))
+assert.equal(personaView(null).name, '当前人设：—')  // no payload -> no throw
+assert.equal(personaView({ persona_profile: { name: 'A' } }).name, '当前人设：A')
+const full = personaView({ persona_profile: { big5: { O: 0.82, C: 0.38, E: 0.93, A: 0.7, N: 0.52 } }, config: { persona_name: 'X' }, persona_text: 'hello world' })
+assert.ok(full.traits.includes('O 0.82'))
+// safeRender isolation: a throwing render must not stop the next one
+const order = []
+safeRender('bad', () => { order.push('bad'); throw new Error('boom') }, () => {})
+safeRender('good', () => { order.push('good') }, () => {})
+assert.deepEqual(order, ['bad', 'good'])
+assert.equal(safeRender('bad2', () => { throw new Error('x') }, () => {}), null)
+console.log('RENDER GUARD OK (11 checks)')

package/python/biocore_model/tests/switch_groups_check.mjs

@@ -0,0 +1,94 @@
+import assert from 'node:assert'
+import { SWITCH_GROUPS, GROUP_ORDER, groupIds, switchIds, advancedCount, classifySwitch, hasChildren, visualWrites, visualReads, FEATURE_SWITCHES, FEATURE_ORDER, featureAbsorbed, featureAbsorbedAll, featureState, featureWrites, featureLabel, compatEmpathy,
+         groupState, expandGroup, groupRowText, normalizeViewMode, VIEW_STORAGE_KEY, TAB_GROUPS, TAB_ORDER,
+         tabOfSwitch, visibleElements, TAB_CONTENT, tabContentCount, visibleInteractive } from '../switch_groups.mjs'
+
+assert.deepEqual(groupIds(), ['memory', 'expression', 'llm', 'safety', 'visual', 'system'])
+assert.equal(advancedCount(), 27)
+const ids = switchIds()
+assert.equal(new Set(ids).size, 27)  // no duplicate / full coverage after visual dedupe
+for (const id of ids) assert.notEqual(classifySwitch(id), '')
+assert.equal(classifySwitch('unknown_switch'), '')
+assert.equal(SWITCH_GROUPS.memory.ids.length, 12)
+assert.equal(SWITCH_GROUPS.expression.ids.length, 4)
+assert.equal(SWITCH_GROUPS.llm.ids.length, 1)
+assert.equal(SWITCH_GROUPS.safety.ids.length, 1)
+assert.equal(SWITCH_GROUPS.visual.ids.length, 9)
+assert.equal(hasChildren('system'), false)
+assert.equal(hasChildren('visual'), true)
+
+assert.equal(groupState('visual', {}), 'off')
+assert.equal(groupState('visual', Object.fromEntries(SWITCH_GROUPS.visual.ids.map((id) => [id, true]))), 'on')
+assert.equal(groupState('visual', { swShowNoise: true }), 'mixed')
+assert.equal(groupState('safety', { swSafetyEnabled: true }), 'on')
+assert.equal(groupState('system', {}), 'off')
+
+const allOn = expandGroup('memory', true)
+assert.equal(Object.values(allOn).filter((value) => value === true).length, 12)
+const allOff = expandGroup('memory', false)
+assert.equal(Object.values(allOff).filter((value) => value === false).length, 12)
+assert.equal(expandGroup('system', true).constructor, Object)
+
+assert.ok(groupRowText('memory').includes('12 项'))
+assert.ok(groupRowText('llm').includes('候选'))
+assert.ok(groupRowText('system').includes('操作按钮'))
+assert.equal(normalizeViewMode(undefined), 'simple')
+assert.equal(normalizeViewMode('advanced'), 'advanced')
+assert.equal(normalizeViewMode('bogus'), 'simple')
+assert.equal(VIEW_STORAGE_KEY, 'biocore_settings_view')
+assert.deepEqual(TAB_ORDER, ['api', 'coreStatus', 'safety', 'llm', 'expression', 'memory', 'visual', 'version', 'backup', 'persona'])
+assert.equal(TAB_GROUPS.coreStatus.length, 0)  // status tab holds no group switches
+assert.ok(TAB_ORDER.length === 10 && !TAB_ORDER.includes('coreMode'))
+for (const tab of ['coreStatus', 'safety', 'llm']) assert.ok(tabContentCount(tab) > 0, tab)
+for (const id of switchIds()) {
+  const tab = tabOfSwitch(id)
+  assert.notEqual(tab, '')
+  assert.notEqual(tab, 'coreStatus')
+}
+assert.equal(tabOfSwitch('swSafetyEnabled'), 'safety')
+assert.equal(tabOfSwitch('fn_empathy_hint_enabled'), 'expression')
+assert.equal(tabOfSwitch('swShowNoise'), 'visual')
+assert.equal(tabOfSwitch('swLlmCandidates'), 'llm')
+assert.equal(tabOfSwitch('swLlmCandidates'), 'llm')
+assert.equal(TAB_GROUPS.persona.length, 0)
+assert.equal(tabOfSwitch('swCompress'), 'memory')
+const simple = visibleElements('simple')
+const advanced = visibleElements('advanced')
+assert.equal(simple.switches, 0)
+assert.equal(advanced.switches, 27)
+assert.ok(advanced.total > simple.total)
+assert.equal(simple.groups, 6)
+assert.equal(advanced.diagnostics, 1)
+const simpleInteractive = visibleInteractive('simple')
+const advancedInteractive = visibleInteractive('advanced')
+assert.ok(simpleInteractive.total <= 12, String(simpleInteractive.total))
+assert.equal(advancedInteractive.individual, 27)
+assert.equal(advancedInteractive.individual + advancedInteractive.groups, 33)
+assert.deepEqual(visualWrites('swShowMemoryNodes', true), { bio_show_memory_nodes: '1', bio_show_nodes: '1' })
+assert.deepEqual(visualWrites('swShowLinks', false), { bio_show_links: '0', bio_show_node_links: '0' })
+assert.deepEqual(visualWrites('swShowEcho', true), { bio_show_echo: '1', bio_show_ripple: '1' })
+assert.equal(visualReads('swShowLinks', { bio_show_links: '0', bio_show_node_links: '1' }), true)  // either true => on
+assert.equal(visualReads('swShowEcho', { bio_show_echo: '0', bio_show_ripple: '0' }), false)
+assert.equal(visualReads('swMemoryBallsImportant', {}), undefined)
+assert.equal(FEATURE_ORDER.length, 11)
+assert.equal(FEATURE_ORDER.length, 11)
+const absorbed = featureAbsorbedAll()
+assert.equal(new Set(absorbed).size, absorbed.length)  // absorbedUnique=20: 11 功能开关吸收的旧键去重后
+assert.ok(absorbed.every((id) => switchIds().includes(id)), 'absorbed ids must be real switches')
+assert.equal(switchIds().length - absorbed.length, 8)  // switchIds=27（页面独立开关）− absorbedUnique=19 = 8 个仅高级项（情绪强度环独立）
+assert.deepEqual(featureWrites('feat_visual_nodes', true), { swShowMemoryNodes: true })
+assert.deepEqual(featureWrites('feat_memory_insight', false), { fn_event_summary_enabled: false, fn_event_ranking_enabled: false, fn_insight_enabled: false, swInsightAuto: false, fn_memory_summary_enabled: false })
+assert.equal(featureState('feat_memory_insight', { fn_event_summary_enabled: true }), 'mixed')
+assert.equal(featureState('feat_safety', { swSafetyEnabled: true }), 'on')
+assert.ok(featureLabel('feat_llm_image').includes('[LLM]'))
+assert.ok(!featureLabel('feat_compress').includes('[LLM]'))
+assert.equal(featureAbsorbed('feat_expression_rules').length, 1)
+assert.deepEqual(featureAbsorbed('feat_visual_rings'), ['swShowEcho','swShowDominance','swShowSocial'])
+const empathy = compatEmpathy(true)
+assert.equal(empathy.localOn, true)          // old empathy_hint=true maps to local expression adjustment
+assert.equal(empathy.llmCallsByDefault, 0)    // and never triggers an LLM call by default
+assert.equal(FEATURE_SWITCHES.feat_expression_rules.local, true)
+assert.equal(FEATURE_SWITCHES.feat_expression_rules.defaultOn, true)
+assert.ok(featureLabel('feat_expression_rules').includes('[本地]'))
+assert.ok(!featureLabel('feat_expression_rules').includes('[LLM]'))
+console.log('SWITCH GROUPS OK (68 checks)')

package/python/biocore_model/tests/tabs_state_check.mjs

@@ -0,0 +1,24 @@
+import assert from 'node:assert'
+import { TAB_STORAGE_KEYS, tabStorageKey, resolveTab, defaultTab, resolveActiveTab, safeRead, safeWrite } from '../tabs_state.mjs'
+
+assert.equal(tabStorageKey('settings'), 'biocore_settings_tab')
+assert.equal(TAB_STORAGE_KEYS.persona !== TAB_STORAGE_KEYS.session, true)
+assert.equal(defaultTab(['settingsApi', 'settingsMemory'], 'settingsApi'), 'settingsApi')
+assert.equal(resolveTab('settingsMemory', ['settingsApi', 'settingsMemory'], 'settingsApi'), 'settingsMemory')
+assert.equal(resolveTab('bogus', ['settingsApi', 'settingsMemory'], 'settingsApi'), 'settingsApi')  // invalid -> fallback
+assert.equal(resolveTab('', ['a'], null), null)
+assert.equal(defaultTab([], 'settingsApi'), 'settingsApi')
+// four combinations: mem present/absent x stored present/absent
+const VALID = ['settingsApi', 'settingsMemory']
+assert.equal(resolveActiveTab({ mem: 'settingsMemory', stored: 'settingsApi', valid: VALID, fallback: 'settingsApi' }), 'settingsMemory')  // mem wins
+assert.equal(resolveActiveTab({ mem: null, stored: 'settingsMemory', valid: VALID, fallback: 'settingsApi' }), 'settingsMemory')       // stored when no mem
+assert.equal(resolveActiveTab({ mem: 'settingsMemory', stored: '', valid: VALID, fallback: 'settingsApi' }), 'settingsMemory')       // mem without storage
+assert.equal(resolveActiveTab({ mem: null, stored: '', valid: VALID, fallback: 'settingsApi' }), 'settingsApi')                       // default
+assert.equal(resolveActiveTab({ mem: 'bogus', stored: 'settingsMemory', valid: VALID, fallback: 'settingsApi' }), 'settingsMemory')    // invalid mem ignored
+// localStorage throws: mem still wins, no default fallback
+const throwing = { getItem() { throw new Error('SecurityError') }, setItem() { throw new Error('SecurityError') } }
+assert.equal(safeRead(throwing, 'x'), '')
+assert.equal(safeWrite(throwing, 'x', 'y'), false)
+const memValue = resolveActiveTab({ mem: 'settingsMemory', stored: safeRead(throwing, 'biocore_settings_tab'), valid: VALID, fallback: 'settingsApi' })
+assert.equal(memValue, 'settingsMemory')  // stub throw must not fall back to default
+console.log('TABS STATE OK (15 checks)')

package/python/biocore_model/tests/test_affective_labor.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from biocore_model import affective_labor as al
+
+NOW = 1_700_000_000
+EXPRESSED = {"v": 0.6, "a": 0.4, "d": 0.5, "social": 0.5}
+FELT = {"v": -0.6, "a": 0.4, "d": 0.5, "social": 0.5}
+
+
+class AffectiveLaborGapTest(unittest.TestCase):
+    def test_identical_state_has_no_gap(self):
+        self.assertEqual(al.deviation(FELT, dict(FELT)), 0.0)
+
+    def test_opposite_valence_is_full_gap(self):
+        self.assertAlmostEqual(al.deviation({"v": -1.0}, {"v": 1.0}), 1.0)
+
+    def test_single_dim_half_gap(self):
+        self.assertAlmostEqual(al.deviation({"v": 0.0}, {"v": 1.0}), 0.5)
+
+    def test_gap_is_weighted_across_present_dims(self):
+        gap = al.deviation({"v": 0.0, "a": 0.5}, {"v": 1.0, "a": 0.5})
+        self.assertAlmostEqual(gap, 0.3)
+
+    def test_missing_dims_do_not_dilute(self):
+        gap = al.deviation({"v": 0.0}, {"v": 1.0, "a": 0.0})
+        self.assertAlmostEqual(gap, 0.5)
+
+    def test_bad_inputs_are_zero_gap(self):
+        self.assertEqual(al.deviation(None, None), 0.0)
+        self.assertEqual(al.deviation({"v": "x"}, {"v": 1.0}), 0.0)
+
+
+class AffectiveLaborCostTest(unittest.TestCase):
+    def test_more_suppression_costs_more(self):
+        honest = al.masking({"v": 0.6}, {"v": -0.6}, honesty=1.0)
+        half = al.masking({"v": 0.6}, {"v": -0.6}, honesty=0.5)
+        hidden = al.masking({"v": 0.6}, {"v": -0.6}, honesty=0.0)
+        self.assertEqual(honest, 0.0)
+        self.assertGreater(half, honest)
+        self.assertGreater(hidden, half)
+
+    def test_energy_cost_is_monotonic(self):
+        self.assertGreater(al.energy_cost(0.8), al.energy_cost(0.2))
+        self.assertAlmostEqual(al.energy_cost(0.5), al.MASK_COST * 0.5)
+
+    def test_honest_turn_is_free(self):
+        self.assertEqual(al.turn_cost(EXPRESSED, FELT, honesty=1.0), 0.0)
+
+    def test_dishonest_turn_costs_energy(self):
+        self.assertGreater(al.turn_cost(EXPRESSED, FELT, honesty=0.0), 0.0)
+
+
+class AffectiveLaborLoadTest(unittest.TestCase):
+    def test_one_hidden_turn_accumulates_load(self):
+        state = al.update(al.initial(NOW - 7200), {"v": 0.0}, {"v": 1.0},
+                          honesty=0.0, now=NOW)
+        self.assertAlmostEqual(state["load"], al.energy_cost(0.5))
+        self.assertEqual(state["turns"], 1)
+
+    def test_same_turn_is_idempotent(self):
+        once = al.update(al.initial(NOW - 10), {"v": 0.0}, {"v": 1.0}, now=NOW)
+        twice = al.update(once, {"v": 0.0}, {"v": 1.0}, now=NOW)
+        self.assertEqual(twice["load"], once["load"])
+        self.assertEqual(twice["turns"], once["turns"])
+
+    def test_load_recovers_over_time(self):
+        state = dict(al.initial(NOW), load=0.80)
+        rested = al.update(state, {"v": 0.5}, {"v": 0.5},
+                           now=NOW + 10 * 3600)
+        self.assertAlmostEqual(rested["load"], 0.50)
+
+    def test_load_is_capped_at_one(self):
+        state = dict(al.initial(NOW - 10), load=0.99)
+        loaded = al.update(state, {"v": 0.6}, {"v": -0.6}, now=NOW)
+        self.assertLessEqual(loaded["load"], 1.0)
+
+    def test_breakdown_counter_on_threshold_crossing(self):
+        state = dict(al.initial(NOW - 10), load=0.80, turns=1)
+        broken = al.update(state, {"v": 0.6}, {"v": -0.6}, now=NOW)
+        self.assertEqual(broken["breakdowns"], 1)
+        self.assertTrue(al.collapsed(broken))
+
+    def test_risk_and_headroom(self):
+        state = dict(al.initial(NOW), load=0.425)
+        self.assertAlmostEqual(al.risk(state), 0.5)
+        self.assertAlmostEqual(al.headroom(state), 0.425)
+        self.assertFalse(al.collapsed(state))
+        heavy = dict(al.initial(NOW), load=0.90)
+        self.assertTrue(al.collapsed(heavy))
+        self.assertEqual(al.headroom(heavy), 0.0)
+
+    def test_view_fields(self):
+        state = al.update(al.initial(NOW - 10), EXPRESSED, FELT, now=NOW)
+        panel = al.view(state)
+        for key in ("load", "threshold", "risk", "headroom", "collapsed",
+                    "last_cost", "last_masking", "turns", "breakdowns"):
+            self.assertIn(key, panel)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_appraisal.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+"""Appraisal dims -> state deltas: matrix, monotonicity, caps, parse, wiring."""
+import unittest
+
+from biocore_model import appraisal as ap
+
+MAIN = __import__("pathlib").Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+def d(**kw):
+    base = {name: 0.0 for name in ap.DIMS}
+    base.update(kw)
+    return base
+
+
+class MatrixTest(unittest.TestCase):
+    def test_weights_shape(self):
+        self.assertEqual(set(ap.WEIGHTS), set(ap.DIMS))
+        for dim in ap.DIMS:
+            self.assertEqual(set(ap.WEIGHTS[dim]), set(ap.OUTPUTS))
+
+    def test_monotonic_goal_v(self):
+        low = ap.appraise(d(goal=0.0), confidence=1.0)
+        high = ap.appraise(d(goal=0.8), confidence=1.0)
+        self.assertGreater(high.get("v", 0.0), low.get("v", 0.0))
+
+    def test_monotonic_blame_self_esteem_and_stress(self):
+        low = ap.appraise(d(blame=0.0), confidence=1.0)
+        high = ap.appraise(d(blame=0.9), confidence=1.0)
+        self.assertLess(high["self_esteem"], low.get("self_esteem", 0.0))
+        self.assertGreater(high["stress"], low.get("stress", 0.0))
+
+    def test_monotonic_hit_social_and_stress(self):
+        low = ap.appraise(d(hit=0.0), confidence=1.0)
+        high = ap.appraise(d(hit=0.9), confidence=1.0)
+        self.assertLess(high["social"], low.get("social", 0.0))
+        self.assertGreater(high["stress"], low.get("stress", 0.0))
+
+    def test_monotonic_control_stress_down(self):
+        low = ap.appraise(d(control=0.0), confidence=1.0)
+        high = ap.appraise(d(control=0.9), confidence=1.0)
+        self.assertLess(high.get("stress", 0.0), low.get("stress", 0.0))
+
+    def test_involve_amplifies(self):
+        cold = ap.appraise(d(goal=0.1, involve=0.0), confidence=1.0)
+        hot = ap.appraise(d(goal=0.1, involve=1.0), confidence=1.0)
+        self.assertGreater(hot["v"], cold["v"])
+        self.assertGreater(hot["trust"], cold["trust"])
+
+    def test_confidence_scales(self):
+        half = ap.appraise(d(goal=0.2, blame=0.2), confidence=0.5)
+        full = ap.appraise(d(goal=0.2, blame=0.2), confidence=1.0)
+        for key in ("v", "stress"):
+            self.assertAlmostEqual(half[key] * 2, full[key], places=3)
+
+    def test_caps(self):
+        out = ap.appraise({name: 1.0 for name in ap.DIMS}, confidence=1.0)
+        for key, value in out.items():
+            self.assertLessEqual(abs(value), ap.CAPS[key] + 1e-9)
+
+    def test_out_of_range_is_clipped(self):
+        clipped = ap.appraise(d(goal=5.0), confidence=1.0)
+        normal = ap.appraise(d(goal=1.0), confidence=1.0)
+        self.assertEqual(clipped, normal)
+        self.assertEqual(ap.appraise(d(blame=-3.0), confidence=1.0), {})
+
+    def test_missing_dims_default(self):
+        self.assertEqual(ap.appraise({}, confidence=1.0), {})
+        out = ap.appraise({"goal": -0.5}, confidence=1.0)
+        self.assertLess(out["v"], 0.0)
+
+
+class ParseTest(unittest.TestCase):
+    RAW = ('{"dims":{"goal":-0.6,"blame":0.8,"control":0.2,"certainty":0.5,'
+           '"novelty":0.3,"involve":0.9,"hit":0.6},"why":"被骂","c":0.8}')
+
+    def test_parse_ok(self):
+        out = ap.parse(self.RAW)
+        self.assertEqual(out["source"], "appraisal")
+        self.assertAlmostEqual(out["dims"]["goal"], -0.6)
+        self.assertEqual(out["why"], "被骂")
+
+    def test_parse_fence_and_clip(self):
+        raw = "\x60\x60\x60json\n" + self.RAW + "\n\x60\x60\x60"
+        out = ap.parse(raw)
+        self.assertEqual(out["dims"]["blame"], 0.8)
+
+    def test_low_confidence_dropped(self):
+        low = self.RAW.replace('"c":0.8', '"c":0.2')
+        self.assertEqual(ap.parse(low), {})
+
+    def test_garbage_dropped(self):
+        self.assertEqual(ap.parse("不是 JSON"), {})
+
+
+class AsyncProbeTest(unittest.IsolatedAsyncioTestCase):
+    async def test_probe_success(self):
+        async def call(prompt):
+            return ParseTest.RAW
+        out = await ap.probe("hi", "", call)
+        self.assertEqual(out["dims"]["hit"], 0.6)
+
+    async def test_probe_timeout_empty(self):
+        async def call(prompt):
+            await __import__("asyncio").sleep(1.0)
+        self.assertEqual(await ap.probe("hi", "", call, timeout=0.05), {})
+
+
+class FeedbackTest(unittest.TestCase):
+    def test_feedback_payload(self):
+        deltas = ap.appraise(d(goal=0.8, hit=0.9), confidence=1.0)
+        payload = ap.feedback_payload(deltas, 0.8, source="user")
+        self.assertIn("valence_delta", payload)
+        self.assertEqual(payload["source"], "user")
+        self.assertAlmostEqual(payload["confidence"], 0.8)
+
+    def test_needs_deltas(self):
+        hurt = ap.needs_deltas(d(blame=1.0, hit=1.0))
+        self.assertLess(hurt["self_esteem"], 0.0)
+        warm = ap.needs_deltas(d(goal=1.0, involve=1.0))
+        self.assertGreater(warm["self_esteem"], 0.0)
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_both_paths_and_fallback(self):
+        self.assertIn("appraisal src=user dims=%s deltas=%s c=%.2f", SOURCE)
+        self.assertIn("appraisal src=reply dims=%s deltas=%s c=%.2f", SOURCE)
+        self.assertIn("lexical_fallback_enabled", SOURCE)
+        self.assertIn("classify_user_msg(text)", SOURCE)
+        self.assertIn("getattr(self, \"lexical_fallback_enabled\", False)", SOURCE)
+        self.assertIn("_appraisal_mod.probe", SOURCE)
+        self.assertIn("appraise(_dims, confidence=_conf)", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_appraisal_action.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import appraisal_action as aa
+
+class AppraisalTest(unittest.TestCase):
+    def test_anxiety_rule(self):
+        self.assertEqual(aa.appraise(-0.5, 0.8, 0.2, 0.6)['emotion'], 'anxiety')
+    def test_anger_rule(self):
+        self.assertEqual(aa.appraise(-0.5, 0.8, 0.8, 0.2)['emotion'], 'anger')
+    def test_sadness_rule(self):
+        self.assertEqual(aa.appraise(-0.5, 0.2, 0.5, 0.5)['emotion'], 'sadness')
+    def test_joy_rule(self):
+        self.assertEqual(aa.appraise(0.6, 0.8, 0.5, 0.5)['emotion'], 'joy')
+    def test_same_event_differs_by_coping(self):
+        low = aa.appraise(-0.5, 0.8, 0.2, 0.6)['emotion']
+        high = aa.appraise(-0.5, 0.8, 0.8, 0.6)['emotion']
+        self.assertNotEqual(low, high)
+    def test_dimensions(self):
+        data = aa.appraisal(0.5, 0.6, 0.7, 0.8, 0.9)
+        for key in aa.DIMS: self.assertIn(key, data)
+    def test_goal_congruence_clamped(self):
+        self.assertLessEqual(aa.appraisal(goal_congruence=5)['goal_congruence'], 1.0)
+
+class ActionTest(unittest.TestCase):
+    def test_anxiety_action(self):
+        a = aa.action_for('anxiety')
+        self.assertGreater(a['drive_delta'], 0); self.assertLess(a['max_chars_mult'], 1.0)
+    def test_sadness_action(self):
+        self.assertLess(aa.action_for('sadness')['drive_delta'], 0)
+    def test_anger_action(self):
+        self.assertGreater(aa.action_for('anger')['drive_delta'], 0)
+    def test_joy_action(self):
+        self.assertGreater(aa.action_for('joy')['max_chars_mult'], 1.0)
+    def test_guilt_action(self):
+        self.assertEqual(aa.action_for('guilt')['repair_delta'], 0.05)
+    def test_unknown_emotion_neutral(self):
+        self.assertEqual(aa.action_for('bogus')['drive_delta'], 0.0)
+
+class CuriosityTest(unittest.TestCase):
+    def test_new_unanswered_raises(self):
+        self.assertGreater(aa.curiosity_update(0.0, new_topic=True, answered=False), 0.0)
+    def test_answered_lowers(self):
+        self.assertLess(aa.curiosity_update(0.5, answered=True), 0.5)
+    def test_decay_hours(self):
+        self.assertLess(aa.curiosity_update(0.5, hours=2), 0.5)
+    def test_effects(self):
+        effects = aa.curiosity_effects(1.0)
+        self.assertAlmostEqual(effects['question_probability_bonus'], 0.3)
+        self.assertAlmostEqual(effects['drive_delta'], 0.02)
+    def test_prompt_line(self):
+        line = aa.prompt_line(aa.action_for('anxiety'), 0.5)
+        self.assertIn('你现在想', line); self.assertIn('好奇', line)
+
+if __name__ == '__main__':
+    unittest.main()