From 502d7ebae45a3a8d8e018e51b94838fcf38d2c19 Mon Sep 17 00:00:00 2001 From: Yuriy Mayatnikov Date: Thu, 28 May 2026 09:34:42 +0300 Subject: [PATCH] fix(v0.3.1): sated bot stops chasing food + perf-leak + fuzzy improvement dedup MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Third day of "bot just walks back and forth burning tokens". Root causes were mechanical, not the manifesto: 1. SATED BOT CHASING FOOD (the big one) Bot had food=17 (nearly full) but storyline first_food + manifesto L1 required 2+ food ITEMS in inventory, so it looped scout-food / acquire-food for hours instead of working. Now both treat a hunger bar >= 14 (SATED_FOOD) as satisfied even with empty food inventory — a full bot chops wood / makes tools and grabs food opportunistically, only hard-pursuing food when actually hungry (< 14). manifesto/needs.js foodDetect + goal/storyline.js first_food.completed. 2. perf_hooks MEMORY LEAK (overnight OOM suspect) "MaxPerformanceEntryBufferExceededWarning: 1,000,001 measure entries". mineflayer/pathfinder emit perf marks we never consume. Added a 60s reaper in bot.js (performance.clearMeasures/clearMarks). unref'd. 3. IMPROVEMENT QUEUE SELF-DUPLICATING The LLM re-filed closed gaps with reworded titles (#5/#8/#9 were dupes of implemented #1/#2/#3). Exact-title dedup missed them. Replaced with token-set fuzzy match (isDuplicateTitle): jaccard>=0.75 OR >=3 shared meaningful tokens with jaccard>=0.5. Also: a re-filed gap that's already implemented/rejected is NOT resurrected as a new open row. Cleared all 5 open requests (now genuinely implemented). Also confirmed (no change needed): - canDig=true is a DELIBERATE codebase-wide choice ("without it the bot gets permanently stuck", actions.js). The stale memory recommending canDig=false is updated. ViaBackwards dig works partially (dug:1 moved:1.8 observed); false would trap the bot in every pit. - scout-food already has blind/tunnel fallback + 12s step timeout (operator's earlier edits) so trapped-pathfinder degrades instead of hanging 30s. Tests: 407 green (was 404). Updated needs/state/storyline tests for the SATED_FOOD threshold; added fuzzy-dedup + tokenize/jaccard tests. Co-Authored-By: Claude Opus 4.7 --- runtime/bot.js | 19 ++++++++ runtime/goal/storyline.js | 17 +++---- runtime/goal/storyline.test.js | 10 ++-- runtime/knowledge/index.js | 73 +++++++++++++++++++++++++---- runtime/knowledge/knowledge.test.js | 36 ++++++++++++++ runtime/manifesto/needs.js | 11 ++++- runtime/manifesto/state.test.js | 12 +++-- 7 files changed, 153 insertions(+), 25 deletions(-) diff --git a/runtime/bot.js b/runtime/bot.js index a48fee7..351c358 100644 --- a/runtime/bot.js +++ b/runtime/bot.js @@ -946,6 +946,25 @@ function tick() { function startTickLoop() { if (tickTimer) clearInterval(tickTimer); tickTimer = setInterval(tick, config.tickIntervalMs); + startPerfBufferReaper(); +} + +// mineflayer + mineflayer-pathfinder emit performance.mark/measure +// entries that accumulate in the global perf_hooks buffer with no +// upper bound. Over a multi-hour run this grew past 1,000,000 entries +// ("MaxPerformanceEntryBufferExceededWarning") and is a prime suspect +// for the overnight OOM. We don't consume those entries, so clear the +// buffer on a slow interval. +let perfReaperTimer = null; +function startPerfBufferReaper() { + if (perfReaperTimer) return; + perfReaperTimer = setInterval(() => { + try { + performance.clearMeasures?.(); + performance.clearMarks?.(); + } catch {} + }, 60_000); + perfReaperTimer.unref?.(); } // ---- IPC commands ---------------------------------------------------------- diff --git a/runtime/goal/storyline.js b/runtime/goal/storyline.js index 3c24fa0..20641b6 100644 --- a/runtime/goal/storyline.js +++ b/runtime/goal/storyline.js @@ -232,16 +232,17 @@ export const STORYLINE = Object.freeze([ title: "Найти первую еду", narration_ru: "Нужна еда — ищу корову, курицу или ягоды.", completed(snap) { - return countAny(snap?.inventory, FOOD_ITEMS) >= 2; + // Done if we have a stock (≥2 food items) OR the hunger bar is + // comfortable (≥14). A sated bot should be chopping wood, not + // chasing a chicken it doesn't need — it'll grab food + // opportunistically when one wanders close. + if (countAny(snap?.inventory, FOOD_ITEMS) >= 2) return true; + if ((snap?.food ?? 20) >= 14) return true; + return false; }, suggestSkill(snap) { - // Two-tier strategy: - // - If a passive food mob is visible nearby (≤24 blocks in - // snapshot), kill it locally with acquire-food. - // - Otherwise scout-food does long-range biome-aware search. - // It commits to a cardinal for ~200 blocks, rescans, and - // on biome boundary detection heads toward food-capable - // terrain. + // Only reached when the bot is actually hungry (food < 14) and + // has no stock. Local mob → acquire-food; else long-range scout. if (hasLocalFoodMob(snap)) return { skillId: "survive.acquire-food" }; return { skillId: "survive.scout-food" }; }, diff --git a/runtime/goal/storyline.test.js b/runtime/goal/storyline.test.js index 56e0a14..bbc5040 100644 --- a/runtime/goal/storyline.test.js +++ b/runtime/goal/storyline.test.js @@ -73,10 +73,14 @@ test("step first_tools: requires all three wood tools", () => { assert.equal(s.completed(snap({ inventory: { stone_pickaxe: 1, stone_axe: 1, stone_sword: 1 } })), true); }); -test("step first_food: completed at ≥2 food items", () => { +test("step first_food: completed at ≥2 food items, OR when sated (food≥14)", () => { const s = getStep("first_food"); - assert.equal(s.completed(snap()), false); - assert.equal(s.completed(snap({ inventory: { bread: 2 } })), true); + // hungry + no food → not done + assert.equal(s.completed(snap({ food: 8 })), false); + // hungry + 2 food items → done (have a stock) + assert.equal(s.completed(snap({ food: 8, inventory: { bread: 2 } })), true); + // sated (food≥14) + no food → done (don't chase food while full) + assert.equal(s.completed(snap({ food: 17 })), true); }); test("step first_food: local hunt only for edible passive mobs within acquire range", () => { diff --git a/runtime/knowledge/index.js b/runtime/knowledge/index.js index cb5938f..10ce71b 100644 --- a/runtime/knowledge/index.js +++ b/runtime/knowledge/index.js @@ -334,16 +334,28 @@ export function createImprovementRequest({ } = {}) { if (!_isAvailable() || !title) return null; try { - // Dedup: if an open request with same title (case-insensitive) exists, - // bump its votes instead of inserting a new row. - const dup = _getStore().prepare(` - SELECT id, votes FROM improvement_requests - WHERE LOWER(title) = LOWER(?) AND status = 'open' - ORDER BY ts DESC LIMIT 1 - `).get(title); - if (dup) { - _getStore().prepare(`UPDATE improvement_requests SET votes = votes + 1 WHERE id = ?`).run(dup.id); - return dup.id; + // Fuzzy dedup: the LLM re-files the same gap with reworded titles + // ("целевого поиска еды" vs "целевого дальнего поиска еды по биому"). + // Exact-title match misses these, so we compare normalized token + // sets against ALL recent requests (any status — a closed/ + // implemented one shouldn't reappear as a fresh open row). On a + // strong overlap we bump votes (if still open) and return, instead + // of inserting a near-duplicate. + const incoming = tokenize(title); + const candidates = _getStore().prepare(` + SELECT id, title, status, votes FROM improvement_requests + ORDER BY ts DESC LIMIT 60 + `).all(); + for (const c of candidates) { + if (isDuplicateTitle(incoming, tokenize(c.title))) { + // Re-flagged gap. If it's still open, count the vote. If it + // was implemented/rejected, do NOT resurrect it — just + // return its id so the caller treats it as "already known". + if (c.status === "open") { + _getStore().prepare(`UPDATE improvement_requests SET votes = votes + 1 WHERE id = ?`).run(c.id); + } + return c.id; + } } const res = _getStore().prepare(` INSERT INTO improvement_requests @@ -412,7 +424,48 @@ export function markImprovementStatus(id, { status, notes } = {}) { function clamp(n, lo, hi) { return Math.max(lo, Math.min(hi, Number(n) || lo)); } +// Normalize a title into a set of meaningful tokens for fuzzy dedup. +// Lowercase, strip punctuation, drop short / stop words (RU + EN) that +// carry no signal ("нет", "навыка", "для", "the", "a", …). +const _STOP = new Set([ + "нет", "навык", "навыка", "для", "из", "по", "в", "на", "и", "с", "к", + "когда", "нужно", "это", "что", "the", "a", "an", "to", "of", "for", + "no", "skill", "has", "is", "low", "rate", +]); +function tokenize(s) { + if (!s || typeof s !== "string") return new Set(); + const words = s.toLowerCase() + .replace(/["'`(),.:;!?\/\\-]+/g, " ") + .split(/\s+/) + .filter((w) => w.length >= 3 && !_STOP.has(w)); + return new Set(words); +} +function jaccard(a, b) { + if (a.size === 0 || b.size === 0) return 0; + let inter = 0; + for (const w of a) if (b.has(w)) inter++; + return inter / (a.size + b.size - inter); +} +function intersectionSize(a, b) { + let n = 0; + for (const w of a) if (b.has(w)) n++; + return n; +} +// Two titles are "the same gap" when they either overlap very strongly +// (jaccard ≥ 0.75) OR share at least 3 meaningful tokens with moderate +// overlap (≥ 0.5). The 3-token floor stops short titles with one or two +// generic words in common ("low-prio thing" vs "high-prio thing") from +// false-matching, while still catching reworded long titles. +function isDuplicateTitle(a, b) { + const j = jaccard(a, b); + if (j >= 0.75) return true; + return intersectionSize(a, b) >= 3 && j >= 0.5; +} + function safeParse(s) { if (!s) return null; try { return JSON.parse(s); } catch { return null; } } + +// Test exports +export const __testing = { tokenize, jaccard, isDuplicateTitle }; diff --git a/runtime/knowledge/knowledge.test.js b/runtime/knowledge/knowledge.test.js index 5d24908..df07573 100644 --- a/runtime/knowledge/knowledge.test.js +++ b/runtime/knowledge/knowledge.test.js @@ -320,6 +320,42 @@ test("improvement requests: create, dedup-by-title bumps votes, list filters", a assert.ok(!stillOpen.some((r) => r.id === id1)); }); +test("improvement requests: fuzzy dedup catches reworded titles + won't resurrect closed ones", async () => { + await bootstrap(); + if (!isAvailable()) return; + const a = createImprovementRequest({ + source: "postmortem", category: "skill", + title: "Нет навыка целевого поиска еды по биому", priority: 1, + }); + assert.ok(a); + // Reworded near-duplicate — should map to the SAME row, bump votes. + const b = createImprovementRequest({ + source: "reflect", category: "skill", + title: "Нет навыка целевого дальнего поиска еды по биому", priority: 1, + }); + assert.equal(b, a, "reworded title deduped to original"); + + // Mark it implemented, then the LLM re-files the same gap reworded + // again — must NOT create a fresh open row (no resurrection). + markImprovementStatus(a, { status: "implemented", notes: "scout-food" }); + const c = createImprovementRequest({ + source: "reflect", category: "skill", + title: "Нужен навык дальнего поиска еды по биому", priority: 1, + }); + assert.equal(c, a, "re-filed closed gap returns existing id, no new row"); + const open = listImprovements({ status: "open" }); + assert.ok(!open.some((r) => r.id === a), "closed gap stays closed"); +}); + +test("tokenize / jaccard: similarity helpers", async () => { + const { tokenize, jaccard } = (await import("./index.js")).__testing; + const t1 = tokenize("Нет навыка целевого поиска еды по биому"); + const t2 = tokenize("Нет навыка целевого дальнего поиска еды по биому"); + assert.ok(jaccard(t1, t2) >= 0.6, `expected ≥0.6, got ${jaccard(t1, t2)}`); + const t3 = tokenize("Trigger wedged_96s has low success rate"); + assert.ok(jaccard(t1, t3) < 0.3, "unrelated titles score low"); +}); + test("improvement requests: priority and status ordering", async () => { await bootstrap(); if (!isAvailable()) return; diff --git a/runtime/manifesto/needs.js b/runtime/manifesto/needs.js index 861f9b6..a2e823d 100644 --- a/runtime/manifesto/needs.js +++ b/runtime/manifesto/needs.js @@ -122,9 +122,18 @@ function alivePursue(s) { return null; } +// SATED_FOOD — above this hunger level the bot is NOT hungry; chasing +// food (scout/acquire) is wasted motion. The bot should keep working +// toward wood/tools/shelter and pick up food opportunistically. It +// only becomes a hard need again when the bar drops below this. +const SATED_FOOD = 14; + function foodDetect(s) { if (!s?.connected) return true; - if ((s.food ?? 20) >= 18 && countAny(s.inventory, FOOD_ITEMS) >= 1) return true; + // Comfortable hunger bar → treat L1 as satisfied even with an empty + // food inventory. (Was: required 6+ food items, which made a sated + // bot loop scout/acquire-food for hours doing nothing else.) + if ((s.food ?? 20) >= SATED_FOOD) return true; return countAny(s.inventory, FOOD_ITEMS) >= 6; } diff --git a/runtime/manifesto/state.test.js b/runtime/manifesto/state.test.js index 1b80b32..9031579 100644 --- a/runtime/manifesto/state.test.js +++ b/runtime/manifesto/state.test.js @@ -33,13 +33,19 @@ test("pickActiveNeed: fresh spawn → L0 alive if zero food", () => { assert.equal(a.skillId, "survive.scout-food"); }); -test("pickActiveNeed: hp ok, no food in inventory → L1 food (scout)", () => { +test("pickActiveNeed: hungry (food<14), no food in inventory → L1 food (scout)", () => { _resetForTest(); - const a = pickActiveNeed(snap()); + const a = pickActiveNeed(snap({ food: 8 })); assert.equal(a.need.id, "food"); assert.equal(a.skillId, "survive.scout-food"); }); +test("pickActiveNeed: sated (food=20) + empty inventory → skips L1, goes to L2 tools_wood", () => { + _resetForTest(); + const a = pickActiveNeed(snap()); + assert.equal(a.need.id, "tools_wood", "sated bot works toward tools, not chasing food"); +}); + test("pickActiveNeed: food covered → L2 tools_wood (gather logs)", () => { _resetForTest(); const a = pickActiveNeed(snap({ inventory: { bread: 8 } })); @@ -103,7 +109,7 @@ test("pickActiveNeed: hostile imminent + low HP → L0 takes over", () => { test("describeActiveNeed: returns 'L → '", () => { _resetForTest(); - const s = describeActiveNeed(snap()); + const s = describeActiveNeed(snap({ food: 8 })); assert.match(s, /^L1 food → /); });