mixdog 0.9.44 → 0.9.46

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/tool-defs.mjs

@@ -8,20 +8,20 @@ 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. Persist with action:"core" op:"add" when: user corrects/confirms your approach, states a durable preference, or says "remember". Core add/edit requires project_id + category + element + summary. Only what code/git/docs cannot derive; include the why. Never transient task state. No prior recall dedup needed — the cycle dedups.',
+    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.',
     inputSchema: {
       type: 'object',
       properties: {
         action: { type: 'string', enum: ['core','status'], description: 'Operation.' },
         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. Max 40 chars.' },
-        summary: { type: 'string', maxLength: 100, description: 'Memory content: 1 fact, 1-2 sentences, max 100 chars.' },
+        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.' },
         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.' },
         confirm: { type: 'string', description: 'Exact confirmation phrase for destructive actions.' },
-        project_id: { type: 'string', description: 'Core pool: common, slug, or *. Required for core add/edit; there is no default pool.' },
+        project_id: { type: 'string', description: 'Core pool: explicit common or slug. Required for core add only (edit uses the id\'s stored pool); there is no default pool.' },
       },
       additionalProperties: false,
       required: ['action'],
@@ -31,7 +31,7 @@ export const TOOL_DEFS = [
     name: 'recall',
     title: 'Recall',
     annotations: { title: 'Recall', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: 'Retrieve stored memory/session history. Call when a task ties to prior work — resumes, continuations, or references to earlier decisions/messages. Do not call as a reflexive pre-step, to verify a just-made decision, or before storing memory. Query is topic/semantic search, not regex. Patterns: period:"last" browses recent sessions; +query narrows topic; sessionId without query for current session; period:"3h"/"30m"/"24h" for recent; YYYY-MM-DD, date ranges, or HH:MM~HH:MM for time windows; id for exact follow-up.',
+    description: 'Retrieve stored memory/session history for prior-work context (resumes, earlier decisions); not a reflexive pre-step. Query is topic/semantic, not regex; period selects the time window; id for exact follow-up.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -44,7 +44,6 @@ export const TOOL_DEFS = [
         category: { anyOf: [{ type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, { type: 'array', items: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, minItems: 1 }], description: 'Category filter.' },
         includeArchived: { type: 'boolean', description: 'Include archived entries.' },
         sessionId: { type: 'string', description: 'Scoped session id.' },
-        session_id: { type: 'string', description: 'Alias for sessionId.' },
         includeMembers: { type: 'boolean', description: 'Include chunk members in output; does not widen the search pool.' },
         includeRaw: { type: 'boolean', description: 'Include unchunked raw/episode rows.' },
         sessionOnly: { type: 'boolean', description: 'Search this session only.' },

package/src/runtime/shared/config.mjs

@@ -14,6 +14,17 @@ import {
   loadLatestMixdogConfigFromBackup,
   hasUserDataInitMarker,
 } from './user-data-guard.mjs'
+import {
+  AGENT_PROVIDER_ENV,
+  AGENT_PROVIDER_ENV_ALIASES,
+  getAgentApiKey,
+} from './provider-api-key.mjs'
+
+export {
+  AGENT_PROVIDER_ENV,
+  AGENT_PROVIDER_ENV_ALIASES,
+  getAgentApiKey,
+}
 
 const _require = createRequire(import.meta.url)
 const { getSecret: _getSecret, setSecret: _setSecret, deleteSecret: _deleteSecret, hasSecret: _hasSecret } = _require('../../lib/keychain-cjs.cjs')
@@ -453,40 +464,6 @@ export function getWebhookAuthtoken() {
   return _readSecret(SECRET_ACCOUNTS.webhookAuth)
 }
 
-// Standard provider env names take precedence so existing OPENAI_API_KEY-style
-// exports keep working, then MIXDOG_AGENT_<P>_APIKEY, then the OS keychain.
-// SSOT for agent API-key providers: setup-server.mjs and config-merge.mjs import
-// this so UI key-presence detection uses the exact same predicate the runtime
-// loads from. Add a provider here and every path picks it up.
-export const AGENT_PROVIDER_ENV = Object.freeze({
-  openai: 'OPENAI_API_KEY', anthropic: 'ANTHROPIC_API_KEY', gemini: 'GEMINI_API_KEY',
-  deepseek: 'DEEPSEEK_API_KEY', xai: 'XAI_API_KEY', 'opencode-go': 'OPENCODE_API_KEY',
-})
-
-// Last-resort env aliases honored AFTER the standard env / MIXDOG_AGENT_* /
-// keychain sources. GROK_API_KEY is the established xAI alias elsewhere in the
-// repo (search discovery, xai-api/grok-oauth backends), so honoring it here
-// keeps provider discovery and dispatch resolving the same credential.
-export const AGENT_PROVIDER_ENV_ALIASES = Object.freeze({
-  xai: ['GROK_API_KEY'],
-})
-
-/**
- * Returns the API key for an agent provider.
- * Priority: <PROVIDER>_API_KEY env -> MIXDOG_AGENT_<PROVIDER>_APIKEY -> keychain('agent.<provider>.apiKey') -> alias env (e.g. GROK_API_KEY for xai) -> null.
- * Never reads mixdog-config.json — provider keys are keychain-only.
- */
-export function getAgentApiKey(provider) {
-  const std = AGENT_PROVIDER_ENV[provider]
-  if (std && process.env[std]) return process.env[std]
-  const fromStore = _readSecret(SECRET_ACCOUNTS.agentApiKey(provider))
-  if (fromStore) return fromStore
-  for (const alias of AGENT_PROVIDER_ENV_ALIASES[provider] || []) {
-    if (process.env[alias]) return process.env[alias]
-  }
-  return null
-}
-
 export function getOpenAIUsageSessionKey() {
   return process.env.OPENAI_USAGE_SESSION_KEY
     || process.env.OPENAI_DASHBOARD_SESSION_KEY