dsh-biocore 0.1.6 → 0.1.8

package/cordis.patch.yml

@@ -8,6 +8,8 @@
         dataDir: ''
         # Memory (task-203): capture both sides, inject <=420 chars, 20/hour.
         memoryEnabled: true
+        # Standalone session/event capture listener (off: capture happens in core turn_start/end)
+        memoryCaptureEnabled: false
         injectMaxChars: 420
         hourlyCap: 20
         # Proactive push (task-205): both switches must be true; default OFF.
@@ -19,4 +21,4 @@
         proactivePerHour: 2
         proactiveMinTrust: 0.6
         proactiveMaxChars: 60
-        proactiveRequireOpenLoop: true
+        proactiveRequireOpenLoop: true

package/lib/index.js

@@ -28,7 +28,7 @@ import { TRACE_ROUTE_PATH, defaultStoreDir, handleTraceRoute } from './modules/t
 import { queueSessionTurn } from './modules/turn-queue.js'
 import { anySwitchOn } from './modules/expression-inject.js'
 import { makeCoreSessionListener, registerCoreTurn } from './modules/core-turn.js'
-import { PLUGIN_DATA_DIR, resolveDataDir } from './modules/data-dir.js'
+import { migrateLegacyPluginData, PLUGIN_DATA_DIR, resolveDataDir } from './modules/data-dir.js'
 import {
   PANEL_MOUNT_PATH,
   PANEL_ROUTE_PREFIX,
@@ -665,7 +665,7 @@ export function makeSessionEventListener(options) {
   }
 }
 
-const CORE_STATE_TTL_MS = 1500
+const CORE_STATE_TTL_MS = 5000
 const CORE_STATE_CACHE = new Map()
 
 /** Read the core pipeline state action (panel state, task-212), briefly cached. */
@@ -726,33 +726,34 @@ export async function handleState(req, res, stateDir, options) {
   const sessionId = cleanSessionId(rawSession)
   if (!sessionId) return sendJson(res, 200, unavailable('bad_session'))
   const stateFile = sessionStateFile(stateDir, sessionId)
-  let read = readStateFile(stateFile)
-  let created = false
+  const read = readStateFile(stateFile)
+  let body = null
   if (read.missing) {
-    const ensured = await ensureState(stateFile, personaProfilePathFor(stateDir))
-    if (!ensured || ensured.ok !== true) {
-      return sendJson(res, 200, unavailable('no_state_yet',
-        { detail: (ensured && (ensured.reason || ensured.detail)) || 'ensure_failed' }))
-    }
-    created = true
-    read = readStateFile(stateFile)
-  }
-  if (read.error) return sendJson(res, 200, unavailable(read.error))
-  let body = projectState(read.state, { mtimeMs: read.mtimeMs, sessionId })
-  // task-202: additive fields for the standalone instrument panel.
-  Object.assign(body, buildPanelExtras(read.state))
-  if (created) body.lazily_created = true
-  // task-212: panel state comes from the core state action when a switch is on.
-  try {
-    const getSwitches = typeof opts.getSwitches === 'function' ? opts.getSwitches : null
-    if (getSwitches && anySwitchOn(getSwitches())) {
-      const core = await fetchCoreState(sessionId, {
-        runAction: opts.runAction,
-        store: opts.store,
-      })
-      body = mergeCoreState(body, core)
+    // Fast path: never call Python when the session file exists. Only a
+    // missing file + an enabled switch may fall back to runtimeAction('state').
+    let core = null
+    try {
+      const getSwitches = typeof opts.getSwitches === 'function' ? opts.getSwitches : null
+      if (getSwitches && anySwitchOn(getSwitches())) {
+        core = await fetchCoreState(sessionId, {
+          runAction: opts.runAction,
+          store: opts.store,
+        })
+      }
+    } catch { core = null }
+    if (!core || core.ok !== true || !core.state || typeof core.state !== 'object') {
+      return sendJson(res, 200, unavailable('no_state_yet'))
     }
-  } catch { /* keep the file projection */ }
+    body = projectState(core.state, { mtimeMs: 0, sessionId })
+    Object.assign(body, buildPanelExtras(core.state))
+    body.source = 'runtime'
+  } else if (read.error) {
+    return sendJson(res, 200, unavailable(read.error))
+  } else {
+    body = projectState(read.state, { mtimeMs: read.mtimeMs, sessionId })
+    Object.assign(body, buildPanelExtras(read.state))
+    body.source = 'file'
+  }
   if (!payloadWithinLimit(body)) {
     return sendJson(res, 200, unavailable('payload_too_large'))
   }
@@ -761,6 +762,7 @@ export async function handleState(req, res, stateDir, options) {
 
 export function apply(ctx, config) {
   const dataDir = resolveDataDir(config)
+  try { migrateLegacyPluginData(dataDir) } catch { /* best-effort data migration */ }
   try { migratePersonaToShared(dataDir) } catch { /* best-effort migration */ }
   const disposers = []
   const keep = (dispose) => {
@@ -866,10 +868,14 @@ export function apply(ctx, config) {
   const memoryDir = resolveMemoryDir(config)
   const injectionState = createInjectionState()
   try {
+    // Normally capture happens inside core turn_start/turn_end. The standalone
+  // session/event capture listener stays available but is opt-in.
+  if (config && config.memoryCaptureEnabled === true) {
     const capture = registerMemoryCapture(ctx, () => config, memoryDir, {
       injectionState,
     })
     if (capture) keep(capture.dispose)
+  }
   } catch { /* memory capture unavailable */ }
   try {
     const injection = registerMemoryInjection(ctx, () => config, memoryDir,

package/lib/modules/core-turn.js

@@ -14,6 +14,8 @@
  * unavailable it falls back to the old adapter bridge once and logs a single
  * warning; all switches off means no python call, no prompt text, no gate.
  */
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
 import { readStateFile, sessionStateFile } from './state.js'
 import { pendingSessionTurn, queueSessionTurn } from './turn-queue.js'
 import {
@@ -105,6 +107,13 @@ export function chooseCleanReply(original, coreCleanText, options) {
   return String(sanitize(source))
 }
 
+export function personaApplied(dataDir) {
+  try {
+    const status = JSON.parse(readFileSync(join(String(dataDir || '').trim(), 'persona_preset.json'), 'utf8'))
+    return status && status.applied === true
+  } catch { return false }
+}
+
 export function turnStartPayload(options) {
   const opts = options || {}
   const expression = opts.expression && typeof opts.expression === 'object'
@@ -114,6 +123,9 @@ export function turnStartPayload(options) {
     user_text: stringId(opts.userText).slice(0, 2000),
     switches: opts.switches || {},
     store: opts.store || defaultStoreDir(),
+    capture: true,
+    memoryEnabled: true,
+    persona_prompt: opts.personaPrompt !== false,
     length_hint: expression.length_hint === true,
     length_target: Number.isFinite(Number(expression.length_target))
       ? Number(expression.length_target) : EXPRESSION_DEFAULTS.length_target,
@@ -132,8 +144,8 @@ export function turnEndPayload(options) {
     user_text: stringId(opts.userText).slice(0, 2000),
     switches: opts.switches || {},
     store: opts.store || defaultStoreDir(),
-    capture: false,
-    memoryEnabled: false,
+    capture: true,
+    memoryEnabled: true,
     sanitize_reply: opts.sanitizeReply !== false,
     diagnostics,
   }, diagnostics, {
@@ -189,6 +201,7 @@ export function makeCoreSessionListener(options) {
           try {
             core = await runAction('turn_start', turnStartPayload({
               sessionId, userText: text, switches, store, expression: getExpression(),
+              personaPrompt: !personaApplied(stateDir),
             }))
           } catch (error) {
             core = { ok: false, reason: 'core_exception' }
@@ -347,4 +360,4 @@ function joinProfile(stateDir) {
   try {
     return stateDir ? String(stateDir).replace(/[\\/]+$/, '') + '/persona_profile.json' : ''
   } catch { return '' }
-}
+}

package/lib/modules/data-dir.js

@@ -4,21 +4,24 @@
  *   <dataDir>/sessions/<session_id>.json   (per-session BioCore state)
  *   <dataDir>/flags.json                   (four switches)
  *
- * Resolution order (task-201):
+ * Resolution order:
  *   1. --profile <name> / --profile=<name> from process.argv
  *      -> <homedir>/.dsh/profiles/<name>/data, only when that profile dir exists
  *   2. config.dataDir (cordis insert config)
  *   3. BIOCORE_UI_DATA_DIR
  *   4. <DSH_PROFILE_DIR>/data -- only when it is a real DSH profile directory
  *      (contains package.json or dsh.yml)
- *   5. <plugin>/data (repo/deployed-copy fallback; never cwd)
+ *   5. <home>/.dsh/profiles/web/data -- when profiles/web/package.json exists
+ *   6. <home>/.dsh/profiles/<only>/data -- exactly one profile under profiles/
+ *   7. <plugin>/data -- last resort, logs __bioDataDirFallback
+ *      (never cwd; previous node_modules data is migrated, not deleted)
  *
  * Why argv first: DSH passes the serving process its own --profile flag, but
  * DSH_PROFILE_DIR in the environment can point at the *default* profile (web)
  * even when the instance runs --profile web-bio. Trusting the env first wrote
  * session state into the wrong profile's data dir.
  */
-import { existsSync } from 'node:fs'
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { fileURLToPath } from 'node:url'
 import { dirname, join, resolve } from 'node:path'
@@ -28,6 +31,10 @@ export const PROFILE_DIR_ENV = 'DSH_PROFILE_DIR'
 export const PROFILE_MARKERS = Object.freeze(['package.json', 'dsh.yml'])
 /** Fallback: the plugin checkout's own data/ directory. */
 export const PLUGIN_DATA_DIR = fileURLToPath(new URL('../../data', import.meta.url))
+export const FALLBACK_WARN_PREFIX = '__bioDataDirFallback'
+export const MIGRATE_LOG_PREFIX = '__bioDataMigrated'
+
+let warnedFallback = false
 
 function text(value) {
   return typeof value === 'string' ? value.trim() : ''
@@ -69,6 +76,71 @@ export function isProfileDir(dir) {
   }
 }
 
+/** <home>/.dsh/profiles */
+export function profilesRootDir(homeDir) {
+  const home = text(homeDir) || homedir()
+  return join(resolve(home), '.dsh', 'profiles')
+}
+
+/** All real profile names directly under <home>/.dsh/profiles. */
+export function listProfiles(homeDir) {
+  const root = profilesRootDir(homeDir)
+  let names = []
+  try {
+    names = readdirSync(root, { withFileTypes: true })
+      .filter((entry) => entry && entry.isDirectory())
+      .map((entry) => entry.name)
+  } catch { return [] }
+  return names.filter((name) => isProfileDir(join(root, name)))
+}
+
+function warnPluginFallback(path) {
+  if (warnedFallback) return
+  warnedFallback = true
+  try {
+    console.error(FALLBACK_WARN_PREFIX + ' using plugin data dir=' + path
+      + ' reason=no-profile-dir (writes will live inside the plugin package)')
+  } catch { /* logging must not throw */ }
+}
+
+/** Copy existing legacy plugin data into the resolved profile dataDir.
+ * Missing files are copied; existing files are never overwritten; the old
+ * plugin copy stays in place for rollback. */
+export function migrateLegacyPluginData(dataDir, legacyDir) {
+  const target = text(dataDir)
+  const source = text(legacyDir) || PLUGIN_DATA_DIR
+  const result = { migrated: false, copied: 0, target, source }
+  if (!target || resolve(target) === resolve(source)) return result
+  // Only migrate into <profile>/data when the parent is a real profile root.
+  const parent = dirname(resolve(target))
+  if (!isProfileDir(parent)) return result
+  const copyIfMissing = (from, to) => {
+    try {
+      if (!existsSync(from) || existsSync(to)) return false
+      mkdirSync(dirname(to), { recursive: true })
+      copyFileSync(from, to)
+      result.copied += 1
+      return true
+    } catch { return false }
+  }
+  const files = ['flags.json', 'persona_profile.json', 'persona.md', 'config.json']
+  for (const name of files) copyIfMissing(join(source, name), join(target, name))
+  try {
+    const sessions = readdirSync(join(source, 'sessions'))
+    for (const name of sessions) {
+      copyIfMissing(join(source, 'sessions', name), join(target, 'sessions', name))
+    }
+  } catch { /* no legacy sessions */ }
+  result.migrated = result.copied > 0
+  if (result.migrated) {
+    try {
+      console.error(MIGRATE_LOG_PREFIX + ' from=' + source + ' to=' + target
+        + ' copied=' + result.copied)
+    } catch { /* logging must not throw */ }
+  }
+  return result
+}
+
 /**
  * Resolve the one directory that owns flags.json and sessions/.
  * @param {object} [config] plugin config (config.dataDir)
@@ -103,5 +175,18 @@ export function resolveDataDir(config, env, argv, homeDir) {
     if (isProfileDir(candidate)) return join(candidate, 'data')
   }
 
-  return resolve(PLUGIN_DATA_DIR)
-}
+  // 5) default web profile, when it is a real profile.
+  const webProfile = join(profilesRootDir(homeDir), 'web')
+  if (isProfileDir(webProfile)) return join(webProfile, 'data')
+
+  // 6) exactly one profile -> deterministic; multiple profiles are ambiguous.
+  const profiles = listProfiles(homeDir)
+  if (profiles.length === 1) {
+    return join(profilesRootDir(homeDir), profiles[0], 'data')
+  }
+
+  // 7) last resort: the plugin package itself.
+  const fallback = resolve(PLUGIN_DATA_DIR)
+  warnPluginFallback(fallback)
+  return fallback
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-biocore",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "description": "BioCore DSH UI: per-session state tab, standalone instrument panel, /api/biocore/state, session/event one_turn updates, /bio sync.",
   "main": "lib/index.js",

package/python/biocore_runtime/pipeline.py

@@ -1780,6 +1780,24 @@ def dispatch(action, payload=None):
             state_store = _relationship_store(data)
             if state_store is not None:
                 _save_session_state(state_store, session_id, session_state)
+            capture_enabled = _as_bool(data.get("capture"), True)
+            captured_user = {"captured": False, "entry_id": "", "reason": "disabled"}
+            capture_store = data.get("store")
+            if capture_enabled and capture_store:
+                user_capture = capture(session_id, "user", user_text, capture_store, {
+                    "enabled": _as_bool(data.get("memoryEnabled", True), True),
+                    "hourly_cap": data.get("hourly_cap", HOURLY_CAP),
+                    "min_chars": data.get("min_chars", MIN_CHARS),
+                })
+                decision = user_capture.get("decision") or {}
+                entry = user_capture.get("entry") or {}
+                captured_user = {
+                    "captured": bool(decision.get("capture")),
+                    "entry_id": str(entry.get("id") or ""),
+                    "reason": str(decision.get("reason") or ""),
+                }
+            elif capture_enabled:
+                captured_user["reason"] = "no_store"
             block = prompt_block(dict(
                 data, phase="turn", session_id=session_id,
                 user_text=user_text,
@@ -1792,7 +1810,8 @@ def dispatch(action, payload=None):
             return {"ok": True, "prompt_block": block["text"],
                     "constraints": self_layer_constraints(
                         dict(data, user_text=user_text)),
-                    "state": session_state}
+                    "state": session_state,
+                    "captured_user": captured_user}
         if action == "turn_end":
             session_id = str(data.get("session_id") or "").strip()
             if not session_id:
@@ -1828,13 +1847,22 @@ def dispatch(action, payload=None):
                     gate["text"] = _sanitize.clean(gate.get("text") or "")
                 except Exception:
                     pass
-            captured = capture(session_id, "assistant", assistant_text, store, {
-                "enabled": _as_bool(data.get("memoryEnabled",
-                                             switches.get("memoryEnabled", True)),
-                                    True),
-                "hourly_cap": data.get("hourly_cap", HOURLY_CAP),
-                "min_chars": data.get("min_chars", MIN_CHARS),
-            })
+            capture_enabled = _as_bool(data.get("capture"), True)
+            capture_store = data.get("store")
+            if capture_enabled and capture_store:
+                captured = capture(session_id, "assistant", assistant_text,
+                                   capture_store, {
+                    "enabled": _as_bool(data.get("memoryEnabled",
+                                                 switches.get("memoryEnabled", True)),
+                                        True),
+                    "hourly_cap": data.get("hourly_cap", HOURLY_CAP),
+                    "min_chars": data.get("min_chars", MIN_CHARS),
+                })
+            else:
+                captured = {"ok": True, "decision": {
+                    "capture": False,
+                    "reason": "disabled" if not capture_enabled else "no_store",
+                }, "entry": None}
             merge_state_relationship_into_shared(session_id, data)
             decision = captured.get("decision") or {}
             entry = captured.get("entry") or {}

package/ui/panel.js

@@ -7,7 +7,7 @@
 (function () {
   'use strict'
 
-  var POLL_MS = 2000
+  var POLL_MS = 5000
   var SESSION = (new URLSearchParams(window.location.search).get('session') || '').trim()
   var SWITCHES = [
     { key: 'safety_enabled', label: '安全闸', desc: '打开后可能拦截/改写回复' },
@@ -1605,9 +1605,18 @@
     loadSeries()
     fetchState()
     fetchTrace()
-    window.setInterval(fetchState, POLL_MS)
-    window.setInterval(fetchTrace, POLL_MS)
+    function pollTick() {
+      if (document.hidden) return
+      fetchState()
+      fetchTrace()
+    }
+    window.setInterval(pollTick, POLL_MS)
     window.setInterval(updateStatusClock, 1000)
+    document.addEventListener('visibilitychange', function () {
+      if (document.hidden) return
+      fetchState()
+      fetchTrace()
+    })
     window.addEventListener('resize', function () { renderChart(lastData) })
   }