mixdog 0.9.45 → 0.9.47

package/src/runtime/agent/orchestrator/tools/builtin.mjs

@@ -410,55 +410,6 @@ function capToolOutput(result, options = {}) {
     return `${head}\n... [tool-output truncated: ${Math.round(bytes / 1024)} KB -> ${Math.round(cap / 1024)} KB cap (tool_output_token_limit)] ...\n${tail}`;
 }
 
-const _GREP_SWEEP_NUDGE_ENABLED = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_ENABLE_GREP_SWEEP_NUDGE || ''));
-const _GREP_SWEEP_MIN_CALLS = 20;
-const _GREP_SWEEP_MIN_UNIQUE = 16;
-const _grepSweepState = new Map();
-
-function _grepSweepTerms(pattern) {
-    const raw = Array.isArray(pattern) ? pattern.join('|') : String(pattern || '');
-    return [...new Set(raw
-        .split(/[|,\s()"'`[\]{}.*+?^$\\:-]+/g)
-        .map((s) => s.trim().toLowerCase())
-        .filter((s) => s.length >= 4))];
-}
-
-function _normalizeSweepPath(value) {
-    return String(value || '.')
-        .replace(/\\/g, '/')
-        .replace(/^([A-Za-z]):/, (_, d) => d.toLowerCase() + ':')
-        .replace(/\/+/g, '/')
-        .replace(/\/$/, '') || '.';
-}
-
-function _grepSweepKey(args = {}) {
-    const path = _normalizeSweepPath(args.path || '.');
-    const glob = Array.isArray(args.glob) ? args.glob.join(',') : String(args.glob || '');
-    const terms = _grepSweepTerms(args.pattern).slice(0, 3).join('|');
-    return `${path}::${glob}::${terms}`;
-}
-
-function _maybeAppendGrepSweepNudge(toolName, args, result, scope) {
-    if (!_GREP_SWEEP_NUDGE_ENABLED || toolName !== 'grep' || typeof result !== 'string') return result;
-    const key = scope || 'global';
-    const now = Date.now();
-    let state = _grepSweepState.get(key);
-    if (!state || now - state.lastTs > 10 * 60_000) {
-        state = { count: 0, unique: new Set(), lastTs: 0, nudged: false };
-        _grepSweepState.set(key, state);
-    }
-    state.count += 1;
-    state.unique.add(_grepSweepKey(args));
-    state.lastTs = now;
-    if (_grepSweepState.size > 256) {
-        const oldest = [..._grepSweepState.entries()].sort((a, b) => (a[1].lastTs || 0) - (b[1].lastTs || 0)).slice(0, 32);
-        for (const [oldKey] of oldest) _grepSweepState.delete(oldKey);
-    }
-    if (state.nudged || state.count < _GREP_SWEEP_MIN_CALLS || state.unique.size < _GREP_SWEEP_MIN_UNIQUE) return result;
-    state.nudged = true;
-    return `${result}\n\n[grep_sweep_hint] Many distinct grep searches were used in this session. Stop rewording search terms; synthesize from existing anchors or switch tools once (code_graph/find/read known regions).`;
-}
-
 export async function executeBuiltinTool(name, args, cwd, options = {}) {
     if (options.abortSignal && !options.signal) {
         options = { ...options, signal: options.abortSignal };
@@ -521,8 +472,7 @@ export async function executeBuiltinTool(name, args, cwd, options = {}) {
             return formatUnknownBuiltinToolMessage(name, args);
     }
     })();
-    const _withNudge = _maybeAppendGrepSweepNudge(toolName, args, _toolResult, readStateScope);
-    return capToolOutput(_appendClampNotices(args, _withNudge), options);
+    return capToolOutput(_appendClampNotices(args, _toolResult), options);
 }
 
 // Surface arg-guard clamp notices (args._clampNotices, see pushClampNotice in

package/src/runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs

@@ -3,13 +3,13 @@ export const CODE_GRAPH_TOOL_DEFS = [
     name: 'code_graph',
     title: 'Code Graph',
     annotations: { title: 'Code Graph', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Repo-local code structure/flow (not web): symbols/references/calls/deps Public files[] must be verified paths; verified source files only. IDs→graph; literal/zero→grep. Exact identifiers: find_symbol/references/callers/callees; keywords: symbol_search/search Unsupported target arrays omitted, never silently mixed. Legacy file/symbol/language compatible, hidden. Batch symbols[]/files[] by mode',
+    description: 'Repo code structure/flow over verified source files only. IDs→graph; literal/zero→grep. Exact identifiers: find_symbol/references/callers/callees; keywords: symbol_search/search. Unsupported target arrays are omitted, never silently mixed. Batch symbols[]/files[] by mode.',
     inputSchema: {
       type: 'object',
       properties: {
-        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'], description: 'Repo-local: file modes={overview,imports,dependents,related,impact}; symbols with files→files[] file outline; symbol modes={find_symbol,symbol_search,search,references,callers,callees}; fileless symbols→symbol_search keywords.' },
-        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Verified source files; supported targets only.' },
-        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Exact identifiers: find_symbol/references/callers/callees; keywords: symbol_search/search; multiple exact symbols use one symbols[] call; one call.' },
+        mode: { type: 'string', enum: ['overview', 'imports', 'dependents', 'related', 'impact', 'symbols', 'find_symbol', 'symbol_search', 'search', 'references', 'callers', 'callees'], description: 'File modes={overview,imports,dependents,related,impact}; symbols with files→files[] file outline; symbol modes={find_symbol,symbol_search,search,references,callers,callees}; fileless symbols→symbol_search keywords.' },
+        files: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Source file path(s); supported targets only.' },
+        symbols: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Exact identifiers (find_symbol/references/callers/callees) or keywords (symbol_search/search); multiple exact symbols use one symbols[] call.' },
         body: { type: 'boolean', description: 'Include body.' },
         limit: { type: 'number', minimum: 1, description: 'Max results.' },
         depth: { type: 'number', minimum: 1, maximum: 5, description: 'Caller depth.' },

package/src/runtime/agent/orchestrator/tools/patch/orchestrator.mjs

@@ -363,7 +363,7 @@ async function apply_patch(args, cwd, options = {}) {
     throw new Error('apply_patch: "patch" is required (unified diff or V4A patch string)');
   }
   if (isCompactedPlaceholderPatch(patchStr)) {
-    throw new Error('patch body is a compacted-history placeholder ([mixdog compacted …]), not real patch content. Re-read the target file span and write a fresh patch; never resubmit compacted output as new tool input.');
+    throw new Error('patch body is a compacted-history placeholder ([mixdog compacted …]), not real patch content and cannot be executed. Re-read the current target file contents now, then construct and submit a fresh full patch from those contents. Do not reuse the marker, omit the patch argument, or reconstruct the old patch from history.');
   }
   const patchByteLen = Buffer.byteLength(patchStr, 'utf8');
   if (patchByteLen > APPLY_PATCH_MAX_BYTES) {

package/src/runtime/agent/orchestrator/tools/patch-manifest.json

@@ -0,0 +1,26 @@
+{
+  "version": "0.7.19",
+  "_comment": "Rewritten by .github/workflows/patch-release.yml on each tagged release. assets maps platformKey (process.platform-process.arch, e.g. win32-x64, linux-x64, darwin-arm64) to { url, sha256 } of the mixdog-patch binary on the GitHub release. A local cargo build under native/mixdog-patch/target/release always takes precedence; otherwise the binary is fetched per this manifest into the data dir (apply is native-only — no JS apply engine).",
+  "assets": {
+    "darwin-arm64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.19/mixdog-patch-darwin-arm64",
+      "sha256": "c808fcfb69d2817fd7678dd364d2e1dd68f6ef2d9807f618bdf110c03ca00ccb"
+    },
+    "darwin-x64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.19/mixdog-patch-darwin-x64",
+      "sha256": "7ed0eeff84796559ca865fc93e7a2a94f2c3fa00126f919064bb8273656fcd85"
+    },
+    "linux-arm64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.19/mixdog-patch-linux-arm64",
+      "sha256": "3cad9c9542f2d97732953a102ef72daf4c79be5361560698d5fd2c5f0c18eda7"
+    },
+    "linux-x64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.19/mixdog-patch-linux-x64",
+      "sha256": "cb0e30346f437811dff19238e1854bd37d97a78f35b13e0b704ebeaa9499ae87"
+    },
+    "win32-x64": {
+      "url": "https://github.com/tribgames/mixdog/releases/download/patch-v0.7.19/mixdog-patch-win32-x64.exe",
+      "sha256": "4bf61a99f63e446570d9d2a9c9ef38475d0d70c0a2b632a5f44d4fe9b684b968"
+    }
+  }
+}

package/src/runtime/memory/index.mjs

@@ -793,7 +793,6 @@ const _httpRouter = createHttpRouter({
   registerClient,
   deregisterClient,
   getDraining: () => _stopPromise != null,
-  getCycle1CallLlm,
   getTraceDb: () => _traceDb,
   setTraceDb: (v) => { _traceDb = v },
   ingestTranscriptFile,

package/src/runtime/memory/lib/core-memory-store.mjs

@@ -39,6 +39,29 @@ function trimOrNull(v) {
   return s === '' ? null : s
 }
 
+export function normalizeCoreInput(input = {}, options = {}) {
+  const summary = trimOrNull(input.summary ?? input.content)
+  const element = trimOrNull(input.element) ?? (summary ? summary.slice(0, CORE_ELEMENT_MAX) : null)
+  const suppliedCategory = trimOrNull(input.category)
+  const category = (suppliedCategory ?? 'fact').toLowerCase()
+  const errors = []
+
+  if (options.requireElement && !element) errors.push('element required')
+  if (options.requireSummary && !summary) errors.push('summary required')
+  if (options.requireCategory && !suppliedCategory) errors.push('category required')
+  if (element && element.length > CORE_ELEMENT_MAX) {
+    errors.push(`element too long (${element.length}/${CORE_ELEMENT_MAX} chars, remove ${element.length - CORE_ELEMENT_MAX})`)
+  }
+  if (summary && summary.length > CORE_SUMMARY_MAX) {
+    errors.push(`summary too long (${summary.length}/${CORE_SUMMARY_MAX} chars, remove ${summary.length - CORE_SUMMARY_MAX})`)
+  }
+  if (suppliedCategory && !VALID_CAT.has(category)) {
+    errors.push(`invalid category "${category}". Valid: ${[...VALID_CAT].join(', ')}`)
+  }
+
+  return { element, summary, category, suppliedCategory, errors }
+}
+
 function _getDb(dataDir) {
   if (!dataDir) throw new Error('core-memory: dataDir required')
   const db = getDatabase(dataDir)
@@ -206,21 +229,14 @@ export async function listCore(dataDir, projectId = null) {
   return r.rows
 }
 
-export async function addCore(dataDir, { element, summary, category }, projectId) {
+export async function addCore(dataDir, input, projectId) {
   if (projectId === undefined) throw new Error('addCore: projectId required — pass null for COMMON pool, or slug string for scoped pool')
-  const el = trimOrNull(element)
-  const sm = trimOrNull(summary) ?? el
-  if (!el || !sm) throw new Error('add requires element and summary')
-  if (el.length > CORE_ELEMENT_MAX) {
-    throw new Error(`core element too long (${el.length}/${CORE_ELEMENT_MAX} chars, remove ${el.length - CORE_ELEMENT_MAX}) — element is a short key/title, not content.`)
-  }
-  if (sm.length > CORE_SUMMARY_MAX) {
-    throw new Error(`core summary too long (${sm.length}/${CORE_SUMMARY_MAX} chars, remove ${sm.length - CORE_SUMMARY_MAX}) — 1 fact in 1-2 sentences; move procedures/multi-step/code to recap or docs.`)
-  }
-  const cat = (trimOrNull(category) ?? 'fact').toLowerCase()
-  if (!VALID_CAT.has(cat)) {
-    throw new Error(`invalid category "${cat}". Valid: ${[...VALID_CAT].join(', ')}`)
-  }
+  const { element: el, summary: sm, category: cat, errors } = normalizeCoreInput(input, {
+    requireElement: true,
+    requireSummary: true,
+    requireCategory: true,
+  })
+  if (errors.length) throw new Error(errors.join('; '))
   const db = _getDb(dataDir)
   const now = Date.now()
   await _backfillNullEmbeddings(db)
@@ -299,19 +315,23 @@ export async function editCore(dataDir, id, patch) {
   const db = _getDb(dataDir)
   const cur = (await db.query(`SELECT * FROM core_entries WHERE id = $1`, [numId])).rows[0]
   if (!cur) throw new Error(`no entry with id=${numId}`)
-  const newElement = trimOrNull(patch.element) ?? cur.element
-  const newSummary = trimOrNull(patch.summary) ?? cur.summary
-  const newCategoryRaw = trimOrNull(patch.category)
-  const newCategory = newCategoryRaw ? newCategoryRaw.toLowerCase() : cur.category
-  if (!VALID_CAT.has(newCategory)) {
-    throw new Error(`invalid category "${newCategory}". Valid: ${[...VALID_CAT].join(', ')}`)
-  }
+  const incoming = normalizeCoreInput(patch)
+  const newElement = incoming.element ?? cur.element
+  const newSummary = incoming.summary ?? cur.summary
+  const newCategory = incoming.suppliedCategory ? incoming.category : cur.category
+  const { errors } = normalizeCoreInput({
+    element: newElement,
+    summary: newSummary,
+    category: newCategory,
+  }, {
+    requireElement: true,
+    requireSummary: true,
+    requireCategory: true,
+  })
+  if (errors.length) throw new Error(errors.join('; '))
   if (newElement === cur.element && newSummary === cur.summary && newCategory === cur.category) {
     throw new Error('no change')
   }
-  if (newSummary && newSummary.length > CORE_SUMMARY_MAX) {
-    throw new Error(`core summary too long (${newSummary.length}/${CORE_SUMMARY_MAX} chars, remove ${newSummary.length - CORE_SUMMARY_MAX}) — 1 fact in 1-2 sentences; move procedures/multi-step/code to recap or docs.`)
-  }
   const now = Date.now()
   const textChanged = newElement !== cur.element || newSummary !== cur.summary
   if (!textChanged) {

package/src/runtime/memory/lib/http-router.mjs

@@ -45,7 +45,6 @@ export function createHttpRouter({
   registerClient,
   deregisterClient,
   getDraining,
-  getCycle1CallLlm,
   getTraceDb,
   setTraceDb,
   ingestTranscriptFile,
@@ -425,198 +424,6 @@ export function createHttpRouter({
       return
     }
 
-    // DEV-ONLY cycle1 chunking bench. Gated by env MIXDOG_DEV_BENCH=1 so
-     // production is untouched (route returns 404 when unset). Mirrors cycle1's
-     // exact fetch query + per-session windowing, then runs each window through
-     // buildCycle1ChunkPrompt + callAgentDispatch + parseCycle1LineFormat. STRICT
-     // read-only — no UPDATE, no transaction, no commit.
-    if (req.method === 'POST' && req.url === '/dev/cycle1-bench') {
-      const db = getDb()
-      // Gate: env MIXDOG_DEV_BENCH=1 OR a runtime flag file, so it can be
-      // toggled without restarting the host agent (env only reaches the worker
-      // on a full CC restart, not via dev-sync full-restart).
-      const _devBenchOn = process.env.MIXDOG_DEV_BENCH === '1'
-        || (DATA_DIR && fs.existsSync(path.join(DATA_DIR, '.dev-bench-enabled')))
-      if (!_devBenchOn) {
-        sendJson(res, { error: 'not found' }, 404)
-        return
-      }
-      if (!isLocalOrigin(req)) {
-        sendJson(res, { ok: false, error: 'forbidden: cross-origin' }, 403)
-        return
-      }
-      try {
-        const body = await readBody(req)
-        const sets = Math.max(1, Number(body?.sets ?? 5))
-        const repeat = Math.max(1, Number(body?.repeat ?? 1))
-        // Optional variant matrix. Each variant: {name, rules}. rules=null → default prompt.
-        const rawVariants = Array.isArray(body?.variants) ? body.variants : null
-        const variants = rawVariants && rawVariants.length > 0
-          ? rawVariants.map((v, i) => ({
-              name: typeof v?.name === 'string' && v.name ? v.name : `variant-${i + 1}`,
-              rules: Array.isArray(v?.rules) ? v.rules : null,
-            }))
-          : null
-
-        // Lazy-load LLM + chunking helpers so production boot pays nothing.
-        // Use the same in-process agent dispatch adapter as real cycle1 — the legacy
-        // agent-ipc callAgentDispatch() path is dead in the detached standalone
-        // memory daemon (no connected IPC), so the dev bench must mirror prod.
-        const [{ buildCycle1ChunkPrompt, parseCycle1LineFormat }, { resolveMaintenancePreset }] = await Promise.all([
-          import('./memory-cycle1.mjs'),
-          import('../../shared/llm/index.mjs'),
-        ])
-        const benchCallLlm = getCycle1CallLlm()
-
-        const CYCLE1_MIN_BATCH = 3
-        const CYCLE1_SESSION_CAP = 10
-        const BATCH_SIZE = 100
-        const TIMEOUT_MS = 180_000
-        const fetchLimit = CYCLE1_SESSION_CAP * BATCH_SIZE
-
-        const fetchResult = await db.query(
-          `SELECT id, ts, role, content, session_id, source_ref, project_id
-           FROM entries
-           WHERE chunk_root IS NULL AND session_id IS NOT NULL
-           ORDER BY ts DESC, id DESC
-           LIMIT $1`,
-          [fetchLimit],
-        )
-        const rowsDesc = fetchResult.rows
-
-        if (rowsDesc.length < CYCLE1_MIN_BATCH) {
-          sendJson(res, {
-            ok: true,
-            sets, repeat,
-            windowsAvailable: 0,
-            note: `not enough pending rows (need >= ${CYCLE1_MIN_BATCH}, got ${rowsDesc.length})`,
-            results: [],
-          })
-          return
-        }
-
-        // Partition by session_id — same as memory-cycle1.mjs _runCycle1Impl L207-233.
-        const sessionMap = new Map()
-        for (const row of rowsDesc.slice().reverse()) {
-          const sid = row.session_id
-          if (!sessionMap.has(sid)) sessionMap.set(sid, [])
-          sessionMap.get(sid).push(row)
-        }
-        const windows = []
-        for (const [sid, sessionRows] of sessionMap) {
-          if (sessionRows.length < CYCLE1_MIN_BATCH) continue
-          const windowCount = Math.max(1, Math.ceil(sessionRows.length / BATCH_SIZE))
-          const baseSize = Math.floor(sessionRows.length / windowCount)
-          const remainder = sessionRows.length % windowCount
-          let _offset = 0
-          for (let i = 0; i < windowCount; i++) {
-            const size = baseSize + (i < remainder ? 1 : 0)
-            windows.push({ sid, rows: sessionRows.slice(_offset, _offset + size) })
-            _offset += size
-          }
-        }
-        const chosen = windows.slice(0, sets)
-
-        const preset = resolveMaintenancePreset('memory')
-
-        function summariseChunks(chunks, totalEntries) {
-          const usedIdx = new Set()
-          for (const c of chunks) for (const i of (c._idxList || [])) usedIdx.add(i)
-          const omitted = []
-          for (let i = 1; i <= totalEntries; i++) if (!usedIdx.has(i)) omitted.push(i)
-          return { covered: usedIdx.size, omitted }
-        }
-
-        // When variants are absent, fall back to a single implicit baseline so the
-        // pre-variant call shape (single rows × repeat) keeps producing the same
-        // {runs:[…]} payload the trigger already knows how to print.
-        const variantList = variants ?? [{ name: 'baseline', rules: null }]
-
-        async function runOnce(rows, customRules) {
-          const userMessage = buildCycle1ChunkPrompt(rows, customRules)
-          const t0 = Date.now()
-          let raw, error
-          try {
-            raw = await benchCallLlm({
-              preset,
-              timeout: TIMEOUT_MS,
-            }, userMessage)
-          } catch (e) {
-            error = e?.message ?? String(e)
-          }
-          const llmMs = Date.now() - t0
-          if (error) return { ok: false, llmMs, error }
-          const parsed = parseCycle1LineFormat(raw)
-          const chunks = Array.isArray(parsed?.chunks) ? parsed.chunks : []
-          const { covered, omitted } = summariseChunks(chunks, rows.length)
-          const ratio = chunks.length > 0
-            ? parseFloat((rows.length / chunks.length).toFixed(2))
-            : null
-          return {
-            ok: true,
-            llmMs,
-            entries: rows.length,
-            chunks: chunks.length,
-            ratio,
-            covered,
-            omitted,
-            chunkList: chunks.map(c => ({
-              idx: c._idxList,
-              element: c.element,
-              category: c.category,
-              summary: c.summary,
-            })),
-          }
-        }
-
-        const results = []
-        for (let s = 0; s < chosen.length; s++) {
-          const { sid, rows } = chosen[s]
-          const sidShort = String(sid).slice(0, 8)
-          if (variants) {
-            // Variant mode: same rows, one run per variant per repeat.
-            const variantResults = []
-            for (const v of variantList) {
-              const runs = []
-              for (let r = 0; r < repeat; r++) {
-                const run = await runOnce(rows, v.rules)
-                runs.push({ repIdx: r + 1, ...run })
-              }
-              variantResults.push({ name: v.name, runs })
-            }
-            results.push({
-              setIdx: s + 1,
-              sessionIdShort: sidShort,
-              entries: rows.length,
-              variants: variantResults,
-            })
-          } else {
-            // Legacy single-baseline payload shape.
-            const runs = []
-            for (let r = 0; r < repeat; r++) {
-              const run = await runOnce(rows, null)
-              runs.push({ repIdx: r + 1, ...run })
-            }
-            results.push({
-              setIdx: s + 1,
-              sessionIdShort: sidShort,
-              entries: rows.length,
-              runs,
-            })
-          }
-        }
-        sendJson(res, {
-          ok: true,
-          sets, repeat,
-          windowsAvailable: windows.length,
-          variants: variants ? variantList.map(v => v.name) : null,
-          results,
-        })
-      } catch (e) {
-        sendError(res, e?.message || String(e))
-      }
-      return
-    }
 
     if (req.method === 'POST' && req.url === '/api/tool') {
       if (!isLocalOrigin(req)) {

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

@@ -33,8 +33,9 @@ import {
   promoteCoreCandidate,
   dismissCoreCandidate,
   CORE_SUMMARY_MAX,
+  normalizeCoreInput,
 } from './core-memory-store.mjs'
-import { resolveProjectScope } from './project-id-resolver.mjs'
+import { resolveProjectId, resolveProjectScope } from './project-id-resolver.mjs'
 import { resolvePluginData } from '../../shared/plugin-paths.mjs'
 import { getMetaValue, isBootstrapComplete } from './memory.mjs'
 
@@ -57,6 +58,7 @@ export function createMemoryActionHandlers({
   getCycle3CallLlm,
   ingestTranscriptFile,
   cwdFromTranscriptPath,
+  editCoreImpl = editCore,
 }) {
   const DATA_DIR = dataDir
 
@@ -643,16 +645,43 @@ export function createMemoryActionHandlers({
       }
       // Local trim helper — the manage-block trimOrNull at :1807 is scoped to
       // that branch and unreachable from here.
-      // Normalize project_id: 'common' (case-insensitive) or null → null (COMMON pool); non-empty string → slug.
+      // Only the explicit string "common" selects the COMMON pool. Core add
+      // validates missing, null, and blank project_id below; edits use the
+      // target entry's stored pool.
       const hasProjectIdKey = Object.prototype.hasOwnProperty.call(args, 'project_id')
+      const projectIdText = typeof args.project_id === 'string' ? args.project_id.trim() : ''
       const projectId = (() => {
-        if (!hasProjectIdKey || args.project_id == null) return null
-        const s = String(args.project_id).trim()
-        if (s === '' || s.toLowerCase() === 'common') return null
-        if (s === '*') return '*'
-        return s
+        if (projectIdText.toLowerCase() === 'common') return null
+        return projectIdText || null
       })()
       try {
+        if (op === 'add' || op === 'edit') {
+          const normalized = normalizeCoreInput(args, {
+            requireElement: true,
+            requireSummary: true,
+            requireCategory: true,
+          })
+          const errors = [...normalized.errors]
+          if (op === 'add') {
+            if (!hasProjectIdKey || !projectIdText) {
+              const inferredProjectId = typeof args.cwd === 'string' && args.cwd
+                ? resolveProjectId(args.cwd)
+                : null
+              errors.unshift(
+                `project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool` +
+                (typeof inferredProjectId === 'string' && /^[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)?$/.test(inferredProjectId)
+                  ? ` (cwd suggests "${inferredProjectId}")`
+                  : ''),
+              )
+            } else if (projectId === '*') {
+              errors.unshift('project_id "*" only valid for op="list"')
+            }
+          }
+          if (errors.length) {
+            return { text: `core ${op}: ${errors.join('; ')}`, isError: true }
+          }
+          args = { ...args, element: normalized.element, summary: normalized.summary, category: normalized.category }
+        }
         if (projectId === '*' && op !== 'list') {
           return { text: `core ${op}: project_id "*" only valid for op="list"`, isError: true }
         }
@@ -681,14 +710,11 @@ export function createMemoryActionHandlers({
           return { text: lines.join('\n') }
         }
         if (op === 'add') {
-          if (!hasProjectIdKey) {
-            return { text: 'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool', isError: true }
-          }
           const entry = await addCore(coreDataDir, args, projectId)
           return { text: `core added (id=${entry.id}): [${entry.category}] ${entry.element} — ${entry.summary.slice(0, 200)}` }
         }
         if (op === 'edit') {
-          const entry = await editCore(coreDataDir, args.id, args)
+          const entry = await editCoreImpl(coreDataDir, args.id, args)
           return { text: `core edited (id=${entry.id}): [${entry.category}] ${entry.element} — ${entry.summary.slice(0, 200)}` }
         }
         if (op === 'delete') {

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