mixdog 0.9.46 → 0.9.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.46",
+  "version": "0.9.47",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/src/defaults/cycle3-review-prompt.md

@@ -23,7 +23,9 @@ CORE is durable standing knowledge that lands in one of three layers:
 - **L3 — Current map:** one-line project-landscape summaries, live long-running
   goals, environment anchors documented nowhere else.
 
-Every entry should be ONE short clause (≤120 chars). CORE is not a log.
+Every entry must be ONE compact ENGLISH clause (≤120 chars), regardless of
+source language. Keep identifiers, paths, and exact phrases coined by the user
+verbatim. CORE is not a log.
 
 ## The distinction that decides every verdict
 
@@ -48,8 +50,10 @@ or inconclusive, keep the CORE entry.
 
 ## Verdicts
 
-- `keep` — durable and already one short clause.
-- `update` — durable but verbose or multi-sentence → rewrite as one ≤120-char clause.
+- `keep` — durable and already one compact ENGLISH clause.
+- `update` — durable but verbose, multi-sentence, or non-English → rewrite as
+  one compact ≤120-char ENGLISH clause; keep identifiers, paths, and exact
+  phrases coined by the user verbatim.
 - `merge` — duplicates another entry → fold into the survivor (same project pool).
 - `reclassify` — the entry is filed under the WRONG project pool. Its subject
   clearly belongs to a different pool shown among the entries under review: a
@@ -81,7 +85,9 @@ or inconclusive, keep the CORE entry.
   `<id>|delete` with no reason, or any reason outside that set, is treated as
   "needs confirmation" and only removed on an explicit APPLY CYCLE3 run.
 
-A verbose durable entry is always `update`, never `keep`.
+A verbose, multi-sentence, or non-English durable entry is always `update`,
+never `keep`; rewrite it as a ≤120-char English clause while keeping
+identifiers, paths, and exact user-coined phrases verbatim.
 Delete is the rarest verdict. Prefer `keep` for durable rules/preferences and
 `update` for compression when the current behavior is still valid.
 Use `superseded` (not `delete`) when the entry WAS a valid durable rule/fact but

package/src/defaults/memory-promote-prompt.md

@@ -47,9 +47,10 @@ Use `why|A` for durable cross-session invariants (L1/L2). Use `why|B` for L3
 current-map entries: one-line project-landscape summaries, live long-running
 goals, and environment anchors documented nowhere else. `why` is validation
 evidence only; it is
-not stored. `core_summary` is injected into Core Memory, so keep it one
-self-contained clause, <=120 chars. For `merge`, `why` and `core` may use the
-survivor `target_row`.
+not stored. `core_summary` is injected into Core Memory, so write it in ENGLISH
+regardless of source language as one compact, self-contained clause, <=120
+chars. Keep code identifiers, paths, and commands verbatim. For `merge`, `why`
+and `core` may use the survivor `target_row`.
 
 Allowed primary verbs:
 

package/src/runtime/memory/lib/memory-cycle2-gate.mjs

@@ -11,11 +11,10 @@ import { __mixdogMemoryLog, throwIfAborted, resourceDir } from './memory-cycle2-
 
 export const CYCLE2_ACTIVE_TARGET_CAP = 100
 
-// Minimum number of active (promoted) rows cycle2 must preserve. When the
-// active pool is at or below this floor, active recheck/demotion is skipped
-// and no archiving path may push active below it — prevents draining the
-// pool to zero. Configurable via config.active_floor.
-export const CYCLE2_ACTIVE_MIN_FLOOR = 20
+// Default active-row floor for cycle2. It is zero so rolling active rechecks
+// always run; protection from archive verdicts is opt-in via
+// config.active_floor.
+export const CYCLE2_ACTIVE_MIN_FLOOR = 0
 
 // Status-based verb whitelist. 3-tier policy: pending → active/archived,
 // active → active/archived/update/merge.
@@ -224,6 +223,15 @@ export function loadCurrentRulesDigest() {
       }
     } catch {}
   }
+  const workflows = join(resourceDir(), 'workflows')
+  try {
+    if (existsSync(workflows)) {
+      for (const dir of readdirSync(workflows).sort()) {
+        const workflow = join(workflows, dir, 'WORKFLOW.md')
+        if (existsSync(workflow)) sources.push(workflow)
+      }
+    }
+  } catch {}
   const parts = []
   for (const p of sources) {
     try {

package/src/runtime/memory/lib/memory-cycle2.mjs

@@ -259,16 +259,19 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
   // over-cap path was historically the ONLY one that re-examined active.
   // Reserve a bounded slice of batch slots for the stalest active rows so
   // rule-duplicate / drifted promotions are archived continuously instead of
-  // sitting forever un-rechecked. Bounded count + reviewed_at rotation
-  // prevents eroding the set to zero (the original over-cap-only concern):
+  // sitting forever un-rechecked. Bounded count + reviewed_at rotation keep
+  // each cycle's exposure small (with the default floor of 0 the pool CAN
+  // erode to zero over repeated cycles if the gate keeps archiving; set
+  // config.active_floor to retain a hard minimum):
   // only the oldest few are re-judged per cycle, and the gate — shown
   // {{CURRENT_RULES}} — keeps genuine A/B entries and archives only
   // restatements. Embedding dedup is skipped on purpose: rule restatements
   // are often cross-language paraphrases whose cosine never clears the merge
   // threshold, but the LLM gate catches the semantic overlap.
-  // Floor guard: when the active pool is at/below the minimum floor, skip the
-  // rolling active recheck entirely so demotions cannot drain it further.
-  const activeRecheckQuota = (reviewActiveRows || activeCount <= activeFloor)
+  // Rolling active recheck always runs outside the over-cap broad review,
+  // including when the active pool is small. Floor protection is opt-in via
+  // config.active_floor and is enforced by the shared floor guard below.
+  const activeRecheckQuota = reviewActiveRows
     ? 0
     : Math.max(0, Math.min(Number(config.active_recheck_quota ?? 8), batchSize - 1))
   const pendingLimit = batchSize - activeRecheckQuota

package/src/runtime/memory/lib/memory-cycle3.mjs

@@ -112,7 +112,30 @@ function coreText(core) {
   return `${core?.element || ''}\n${core?.summary || ''}`
 }
 
-function isSafeConservativeUpdate(current, action) {
+function hasSubstantialNonLatinScript(value) {
+  const text = String(value ?? '')
+  const letters = text.match(/\p{L}/gu) || []
+  const latinLetters = letters.filter((letter) => /\p{Script=Latin}/u.test(letter))
+  const nonLatinLetters = letters.length - latinLetters.length
+  return nonLatinLetters >= 3 && nonLatinLetters >= letters.length * 0.3
+}
+
+function cosineSimilarity(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length === 0 || a.length !== b.length) return null
+  let dot = 0
+  let aNorm = 0
+  let bNorm = 0
+  for (let i = 0; i < a.length; i++) {
+    if (!Number.isFinite(a[i]) || !Number.isFinite(b[i])) return null
+    dot += a[i] * b[i]
+    aNorm += a[i] ** 2
+    bNorm += b[i] ** 2
+  }
+  if (aNorm === 0 || bNorm === 0) return null
+  return dot / Math.sqrt(aNorm * bNorm)
+}
+
+async function isSafeConservativeUpdate(current, action) {
   if (!current || !action?.element || !action?.summary) return { ok: false, reason: 'missing text' }
   const newElement = normalizeComparable(action.element)
   const newSummary = normalizeComparable(action.summary)
@@ -123,11 +146,23 @@ function isSafeConservativeUpdate(current, action) {
   const newText = `${action.element}\n${action.summary}`
   const oldLen = normalizeComparable(oldText).length
   const newLen = normalizeComparable(newText).length
-  if (oldLen > 0 && newLen > oldLen + 20) return { ok: false, reason: 'rewrite expands entry' }
-
   const sim = charDice(oldText, newText)
-  if (sim < 0.28) return { ok: false, reason: `rewrite drift sim=${sim.toFixed(2)}` }
-  return { ok: true, reason: 'safe compression' }
+  const crossLanguageRewrite = sim < 0.28 && hasSubstantialNonLatinScript(oldText)
+  if (!crossLanguageRewrite) {
+    if (oldLen > 0 && newLen > oldLen + 20) return { ok: false, reason: 'rewrite expands entry' }
+    if (sim < 0.28) return { ok: false, reason: `rewrite drift sim=${sim.toFixed(2)}` }
+    return { ok: true, reason: 'safe compression' }
+  }
+
+  try {
+    const [oldEmbedding, newEmbedding] = await Promise.all([embedText(oldText), embedText(newText)])
+    const cosine = cosineSimilarity(oldEmbedding, newEmbedding)
+    if (cosine == null) return { ok: false, reason: 'cross-language embedding invalid' }
+    if (cosine < 0.6) return { ok: false, reason: `cross-language semantic drift cosine=${cosine.toFixed(2)}` }
+    return { ok: true, reason: `safe cross-language rewrite cosine=${cosine.toFixed(2)}` }
+  } catch (err) {
+    return { ok: false, reason: `cross-language embedding failed: ${err?.message || 'unknown error'}` }
+  }
 }
 
 function findElementConflict(coreById, currentId, element, projectId) {
@@ -659,7 +694,7 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
     }
     if (a.verb === 'update') {
       proposed.updated++
-      const safety = conservative ? isSafeConservativeUpdate(coreById.get(a.id), a) : { ok: true, reason: 'confirmed' }
+      const safety = conservative ? await isSafeConservativeUpdate(coreById.get(a.id), a) : { ok: true, reason: 'confirmed' }
       const conflictId = conservative
         ? findElementConflict(coreById, a.id, a.element, coreById.get(a.id)?.project_id ?? null)
         : null

package/src/runtime/memory/lib/query-handlers.mjs

@@ -49,7 +49,7 @@ export function createQueryHandlers({
   // Raw-row priority lookup for narrow-window queries. Raw rows (is_root=0,
   // chunk_root IS NULL) are inserted immediately by ingestTranscriptFile before
   // cycle1 runs, so they always carry the freshest turns in the DB.
-  async function readRawRowsInWindow(db, tsFromMs, tsToMs, hardLimit = 10, { projectScope, sessionId, terms } = {}) {
+  async function readRawRowsInWindow(db, tsFromMs, tsToMs, hardLimit = 10, { projectScope, sessionId, terms, minHits: minHitsOverride } = {}) {
     try {
       // Composable WHERE assembly (mirrors retrieveEntries' filter semantics so
       // raw and chunked legs stay in filter parity: projectScope AND sessionId
@@ -78,7 +78,9 @@ export function createQueryHandlers({
         // into the page. 1-2 term queries keep single-hit contains semantics —
         // short Korean queries are often exactly two meaningful tokens and a
         // 2-of-2 requirement silently emptied the raw leg for them.
-        const minHits = terms.length >= 3 ? 2 : 1
+        const minHits = Number.isFinite(Number(minHitsOverride))
+          ? Math.max(1, Math.floor(Number(minHitsOverride)))
+          : (terms.length >= 3 ? 2 : 1)
         where.push(`(${clauses.join(' + ')}) >= ${minHits}`)
       }
       params.push(hardLimit)
@@ -722,7 +724,7 @@ export function createQueryHandlers({
       // Deterministic tie-breaker: equal MAX(ts) across sessions would let the
       // LIMIT/OFFSET window skip or duplicate a session between offset pages
       // without a stable secondary sort.
-      const sessSql = `SELECT session_id, MAX(ts) AS last_ts
+      const sessSql = `SELECT session_id, MIN(ts) AS first_ts, MAX(ts) AS last_ts
                        FROM entries
                        WHERE ${selWhere.join(' AND ')}
                        GROUP BY session_id
@@ -732,6 +734,7 @@ export function createQueryHandlers({
       // 2) per selected session, fetch its newest rows (roots+members, sort by
       //    date) plus the fresh raw window, capped at PER_SESSION_ROW_CAP.
       const allRows = []
+      const sessionMeta = new Map()
       for (const s of sessRows) {
         const sid = String(s?.session_id || '').trim()
         if (!sid) continue
@@ -743,7 +746,24 @@ export function createQueryHandlers({
         const sRows = await retrieveEntries(db, sf)
         let merged = sRows
         if (includeRaw) {
-          const rawRows = await readRawRowsInWindow(db, null, Date.now(), perSessionFetchCap, { projectScope, sessionId: sid, terms: queryTerms })
+          let rawRows
+          if (queryTerms.length > 0) {
+            // Keep a full unfiltered recency window for the newest-row floor,
+            // while separately retaining the deeper term-matched raw window.
+            const [recentRawRows, matchedRawRows] = await Promise.all([
+              readRawRowsInWindow(db, null, Date.now(), perSessionFetchCap, { projectScope, sessionId: sid, terms: [] }),
+              readRawRowsInWindow(db, null, Date.now(), perSessionFetchCap, { projectScope, sessionId: sid, terms: queryTerms, minHits: 1 }),
+            ])
+            const rawIds = new Set()
+            rawRows = [...recentRawRows, ...matchedRawRows].filter((r) => {
+              const id = Number(r.id)
+              if (rawIds.has(id)) return false
+              rawIds.add(id)
+              return true
+            })
+          } else {
+            rawRows = await readRawRowsInWindow(db, null, Date.now(), perSessionFetchCap, { projectScope, sessionId: sid, terms: [] })
+          }
           const seenIds = new Set(sRows.map((r) => Number(r.id)))
           for (const r of sRows) if (Array.isArray(r.members)) for (const m of r.members) seenIds.add(Number(m.id))
           // readRawRowsInWindow carries no category filter, so a category-
@@ -768,14 +788,37 @@ export function createQueryHandlers({
             merged.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0) || (Number(b.id) || 0) - (Number(a.id) || 0))
           }
         }
+        const fetchedCount = merged.length
+        let queryFiltered = false
         if (queryTerms.length > 0) {
-          merged = merged.filter(matchesQueryTerms)
+          const newestRows = merged.slice(0, 3)
+          const newestIds = new Set(newestRows.map((r) => r.id))
+          const matchedRows = merged.filter(matchesQueryTerms)
+          // A topic query must not obscure a session's latest activity: keep
+          // its three newest rows, then use term matches for the remaining
+          // display slots without duplicating rows already kept for recency.
+          merged = [...newestRows, ...matchedRows.filter((r) => !newestIds.has(r.id))]
+          // Only mark query filtering when its floor+match union actually
+          // excludes fetched rows. The later display cap is independent.
+          queryFiltered = merged.length < fetchedCount
         }
         merged = merged.slice(0, PER_SESSION_ROW_CAP)
+        sessionMeta.set(sid, {
+          minTs: Number(s.first_ts),
+          maxTs: Number(s.last_ts),
+          fetchedCount,
+          shownCount: merged.length,
+          queryFiltered,
+        })
         for (const r of merged) allRows.push(r)
       }
       const _currentSessionHint = String(args?.currentSessionId || '').trim()
-      return { text: recallCapPrefix + renderSessionGroupedLines(allRows, { currentSessionId: _currentSessionHint, recencyOrder: true, spanHeaders: true }) }
+      return { text: recallCapPrefix + renderSessionGroupedLines(allRows, {
+        currentSessionId: _currentSessionHint,
+        recencyOrder: true,
+        spanHeaders: true,
+        sessionMeta,
+      }) }
     }
 
     const filters = { limit: limit + offset }

package/src/runtime/memory/lib/recall-format.mjs

@@ -336,10 +336,16 @@ function spanHeaderSuffix(minTs, maxTs, n) {
 // group's lines are globally ts-desc: without it a chunk root's members (stored
 // ts-ASC) interleave with raw rows and invert the visible timeline within a
 // session (e.g. 04:33 rendered above 04:41).
-export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder = false, spanHeaders = false } = {}) {
-  if (!rows || rows.length === 0) return '(no results)'
+export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder = false, spanHeaders = false, sessionMeta } = {}) {
+  const hasSessionMeta = spanHeaders && Number(sessionMeta?.size) > 0
+  if ((!rows || rows.length === 0) && !hasSessionMeta) return '(no results)'
   const groups = new Map()
-  for (const r of rows) {
+  // Seed selected sessions so an entirely query-filtered session still
+  // reports its real activity span and filtering status.
+  if (hasSessionMeta) {
+    for (const sid of sessionMeta.keys()) groups.set(sid, [])
+  }
+  for (const r of rows || []) {
     const sid = String(r?.session_id || '').trim()
     const key = sid || '(no session)'
     if (!groups.has(key)) groups.set(key, [])
@@ -356,11 +362,20 @@ export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder
     for (const [sid, groupRows] of groups) {
       const mark = current && sid === current ? ' (current)' : ''
       const label = sid === '(no session)' ? sid : `session ${shortSessionLabel(sid)}`
+      const meta = sessionMeta?.get?.(sid)
       const tsAll = collectGroupTs(groupRows)
-      const suffix = tsAll.length
-        ? ` ${spanHeaderSuffix(Math.min(...tsAll), Math.max(...tsAll), groupRows.length)}`
+      const minTs = Number(meta?.minTs)
+      const maxTs = Number(meta?.maxTs)
+      const hasActivitySpan = Number.isFinite(minTs) && Number.isFinite(maxTs)
+      const suffix = hasActivitySpan
+        ? ` ${spanHeaderSuffix(minTs, maxTs, groupRows.length)}`
+        : tsAll.length
+          ? ` ${spanHeaderSuffix(Math.min(...tsAll), Math.max(...tsAll), groupRows.length)}`
         : ` (${groupRows.length} entries)`
-      parts.push(`## ${label}${mark}${suffix}`)
+      const filterNote = meta?.queryFiltered
+        ? ` · query-filtered ${meta.shownCount}/${meta.fetchedCount} rows`
+        : ''
+      parts.push(`## ${label}${mark}${suffix}${filterNote}`)
       const bodyStr = renderEntryLines(groupRows, { recencyOrder })
       const bodyLines = bodyStr === '(no results)'
         ? []

package/src/runtime/memory/tool-defs.mjs

@@ -8,7 +8,7 @@ export const TOOL_DEFS = [
     name: 'memory',
     title: 'Memory Cycle',
     annotations: { title: 'Memory Cycle', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-    description: 'Core-memory mutation and status; use recall for retrieval. Store durable rules/preferences/facts, one short clause each — never transient task state. add requires project_id+category+summary; edit works by id alone.',
+    description: 'Core-memory mutation and status; use recall for retrieval. Store durable rules/preferences/facts, one compact ENGLISH clause each — never transient task state. add requires project_id+category+summary; edit works by id alone.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -16,7 +16,7 @@ export const TOOL_DEFS = [
         op: { type: 'string', enum: ['add','edit','delete','list','candidates','promote','dismiss'], description: 'Mutation op. candidates/promote/dismiss drive core-memory proposal approval.' },
         id: { type: 'number', description: 'Exact memory id.' },
         element: { type: 'string', maxLength: 40, description: 'Memory key/title. Defaults to the first 40 chars of summary. Max 40 chars.' },
-        summary: { type: 'string', maxLength: 100, description: 'Memory content: one short fact, max 100 chars.' },
+        summary: { type: 'string', maxLength: 100, description: 'Memory content: one short English clause, max 100 chars.' },
         category: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'], description: 'Category.' },
         status: { type: 'string', enum: ['pending','active','archived'], description: 'Lifecycle status.' },
         limit: { type: 'number', description: 'Max rows/items.' },