wormclaude 1.0.0

package/dist/i18n.js

@@ -0,0 +1,177 @@
+// Çoklu dil (TR/EN) — arayüz metinleri. İlk açılışta dil seçilir, .wormclaude/settings.json'a yazılır.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+let current = 'tr';
+export function setLang(l) { current = l; }
+export function getLang() { return current; }
+// Klasör bazlı ayar: her proje klasöründe bir kez sorulur (.wormclaude/settings.json)
+const SETTINGS = path.join(process.cwd(), '.wormclaude', 'settings.json');
+export function loadLang() {
+    try {
+        const j = JSON.parse(fs.readFileSync(SETTINGS, 'utf8'));
+        if (j.lang === 'tr' || j.lang === 'en')
+            return j.lang;
+    }
+    catch { }
+    return null;
+}
+export function saveLang(l) {
+    let j = {};
+    try {
+        j = JSON.parse(fs.readFileSync(SETTINGS, 'utf8'));
+    }
+    catch { }
+    j.lang = l;
+    try {
+        fs.mkdirSync(path.dirname(SETTINGS), { recursive: true });
+        fs.writeFileSync(SETTINGS, JSON.stringify(j, null, 2));
+    }
+    catch { }
+}
+const STR = {
+    tr: {
+        'lang.title': 'Dil seçin / Select language',
+        'lang.tr': '1. Türkçe',
+        'lang.en': '2. English',
+        'lang.hint': 'Enter onayla · ↑↓ veya 1-2 seç',
+        'trust.accessing': 'Çalışma alanına erişiliyor:',
+        'trust.check': 'Güvenlik kontrolü: Bu, senin oluşturduğun ya da güvendiğin bir proje mi?\n(Kendi kodun, bilinen bir açık-kaynak proje, ya da ekibinin işi gibi.)\nDeğilse devam etmeden içeriğine bak.',
+        'trust.canDo': 'WormClaude bu klasörde dosya okuyup, düzenleyip komut çalıştırabilir.',
+        'trust.yes': '1. Evet, bu klasöre güveniyorum',
+        'trust.no': '2. Hayır, çık',
+        'trust.hint': 'Enter onayla · Esc iptal · ↑↓ veya 1-2 seç',
+        'banner.subtitle': 'uncensored security + code  ·  /help komutlar',
+        'input.placeholder': 'bir şey yaz... (/ komutlar)',
+        'menu.navHint': '↑↓ gez · Enter seç',
+        'menu.noCmd': '(komut yok)',
+        'menu.moreUp': '↑ {0} daha…',
+        'menu.moreDown': '↓ {0} daha…',
+        'perm.title': 'İzin gerekiyor: {0}',
+        'perm.yes': '1. Evet, çalıştır',
+        'perm.yesAlways': '2. Evet, bu araç için bir daha sorma',
+        'perm.no': '3. Hayır — bunun yerine ne yapılacağını söyle',
+        'perm.hint': '↑↓ / 1-3 seç · Enter onayla · Esc reddet',
+        'perm.feedbackPrompt': 'Ne yapılmasını istiyorsun? (boş bırakıp Enter = sadece reddet)',
+        'perm.feedbackPlaceholder': 'yönlendirmeni yaz...',
+        'note.interrupted': 'Kesildi (Esc).',
+        'note.autoCompacted': 'Bağlam otomatik özetlendi (oto-compact).',
+        'note.reactive': 'Bağlam taştı — özetlenip yeniden deneniyor (reactive compact).',
+        'note.budget': 'Bütçe limiti aşıldı (${0}). Durduruldu.',
+        'note.maxTurns': 'Maks tur ({0}) ulaşıldı.',
+        'note.cmdErr': 'Komut hatası: {0}',
+        'phase.autoCompact': 'Oto-compact (bağlam doluyor)',
+        'phase.cmd': 'Komut: {0}',
+        'phase.toolsMulti': '{0} araç çalışıyor',
+        'phase.toolRun': 'Çalıştırıyor: {0}',
+        'mcp.connected': 'MCP: {0} sunucu bağlı, {1} araç',
+        'mcp.errors': ' · {0} hata ({1})',
+        'pill.running': '⏳ {0} çalışıyor',
+        'pill.done': '✓ {0} görev bitti',
+    },
+    en: {
+        'lang.title': 'Select language / Dil seçin',
+        'lang.tr': '1. Türkçe',
+        'lang.en': '2. English',
+        'lang.hint': 'Enter to confirm · ↑↓ or 1-2 to select',
+        'trust.accessing': 'Accessing workspace:',
+        'trust.check': 'Security check: Is this a project you created or trust?\n(Your own code, a known open-source project, or your team\'s work.)\nIf not, review its contents before continuing.',
+        'trust.canDo': 'WormClaude can read, edit files and run commands in this folder.',
+        'trust.yes': '1. Yes, I trust this folder',
+        'trust.no': '2. No, exit',
+        'trust.hint': 'Enter to confirm · Esc to cancel · ↑↓ or 1-2 to select',
+        'banner.subtitle': 'uncensored security + code  ·  /help commands',
+        'input.placeholder': 'type something... (/ for commands)',
+        'menu.navHint': '↑↓ move · Enter select',
+        'menu.noCmd': '(no command)',
+        'menu.moreUp': '↑ {0} more…',
+        'menu.moreDown': '↓ {0} more…',
+        'perm.title': 'Permission needed: {0}',
+        'perm.yes': '1. Yes, run it',
+        'perm.yesAlways': '2. Yes, don\'t ask again for this tool',
+        'perm.no': '3. No, suggest changes',
+        'perm.hint': '↑↓ / 1-3 select · Enter confirm · Esc deny',
+        'perm.feedbackPrompt': 'What should it do instead? (leave empty + Enter = just reject)',
+        'perm.feedbackPlaceholder': 'type your guidance...',
+        'note.interrupted': 'Interrupted (Esc).',
+        'note.autoCompacted': 'Context auto-summarized (auto-compact).',
+        'note.reactive': 'Context overflowed — summarizing and retrying (reactive compact).',
+        'note.budget': 'Budget limit exceeded (${0}). Stopped.',
+        'note.maxTurns': 'Max turns ({0}) reached.',
+        'note.cmdErr': 'Command error: {0}',
+        'phase.autoCompact': 'Auto-compact (context filling)',
+        'phase.cmd': 'Command: {0}',
+        'phase.toolsMulti': '{0} tools running',
+        'phase.toolRun': 'Running: {0}',
+        'mcp.connected': 'MCP: {0} server(s) connected, {1} tool(s)',
+        'mcp.errors': ' · {0} error ({1})',
+        'pill.running': '⏳ {0} running',
+        'pill.done': '✓ {0} task(s) done',
+    },
+};
+// Komut açıklamaları (slash menüsü + /help)
+const CMD_DESC = {
+    tr: {
+        '/help': 'komutları ve ipuçlarını göster',
+        '/clear': 'sohbeti ve geçmişi temizle',
+        '/compact': 'geçmişi modelle özetleyip bağlamı küçült',
+        '/context': 'bağlam / token kullanımını göster',
+        '/cost': 'oturum token ve maliyetini göster',
+        '/config': 'ayarları göster / değiştir (url, key, model)',
+        '/model': 'modeli göster / değiştir',
+        '/diff': 'git diff göster',
+        '/commit': 'stage edilmiş değişiklikleri modelle commit et',
+        '/review': 'mevcut diff’i modelle incele',
+        '/init': 'projeyi tarayıp WORMCLAUDE.md üret',
+        '/memory': 'WORMCLAUDE.md hafızasını oku / satır ekle',
+        '/doctor': 'sistem ve backend sağlık kontrolü',
+        '/mcp': 'MCP sunucularını listele / yeniden bağlan',
+        '/tasks': 'arka plan görevlerini (shell/agent) listele',
+        '/kill': 'bir arka plan görevini durdur: /kill <id>',
+        '/dream': 'arka planda hafızayı konsolide et',
+        '/lang': 'arayüz dilini değiştir (tr/en)',
+        '/skills': 'skill\'leri listele / indir / yeniden yükle',
+        '/skillify': 'bu oturumu yeniden kullanılabilir skill\'e çevir',
+        '/learn': 'web-öğrenme datasını göster / aç-kapa (eğitim için)',
+        '/agent': 'tek bir alt-agent\'a görev ver: /agent <görev>',
+        '/multi-agent': 'paralel çoklu-agent koordinasyonu: /multi-agent <görev>',
+        '/export': 'sohbeti dosyaya kaydet',
+        '/resume': 'en son kaydedilen oturumu yükle',
+        '/quit': 'çıkış',
+    },
+    en: {
+        '/help': 'show commands and tips',
+        '/clear': 'clear conversation and history',
+        '/compact': 'summarize history with the model to shrink context',
+        '/context': 'show context / token usage',
+        '/cost': 'show session tokens and cost',
+        '/config': 'show / change settings (url, key, model)',
+        '/model': 'show / change the model',
+        '/diff': 'show git diff',
+        '/commit': 'commit staged changes with a model-written message',
+        '/review': 'review the current diff with the model',
+        '/init': 'scan the project and generate WORMCLAUDE.md',
+        '/memory': 'read WORMCLAUDE.md memory / append a line',
+        '/doctor': 'system and backend health check',
+        '/mcp': 'list MCP servers / reconnect',
+        '/tasks': 'list background tasks (shell/agent)',
+        '/kill': 'stop a background task: /kill <id>',
+        '/dream': 'consolidate memory in the background',
+        '/lang': 'change interface language (tr/en)',
+        '/skills': 'list / install / reload skills',
+        '/skillify': 'turn this session into a reusable skill',
+        '/learn': 'show / toggle web-learning training data',
+        '/agent': 'give a task to one sub-agent: /agent <task>',
+        '/multi-agent': 'parallel multi-agent coordination: /multi-agent <task>',
+        '/export': 'save the conversation to a file',
+        '/resume': 'load the most recently saved session',
+        '/quit': 'exit',
+    },
+};
+export function t(key, ...args) {
+    let s = STR[current][key] ?? STR.tr[key] ?? key;
+    args.forEach((a, i) => { s = s.replace(`{${i}}`, String(a)); });
+    return s;
+}
+export function cmdDesc(name) {
+    return CMD_DESC[current][name] ?? CMD_DESC.tr[name] ?? '';
+}

package/dist/learn.js

@@ -0,0 +1,47 @@
+// Öğrenme döngüsü — model web'de arayıp cevap üretince, {soru→cevap} çiftini
+// SFT eğitim formatında (instruction/response/kat/len) dosyaya yazar.
+// Sonra modelegitim/build_sft + LoRA ile model bu konuyu KALICI öğrenir.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const DIR = path.join(process.cwd(), '.wormclaude', 'training');
+const FILE = path.join(DIR, 'learned.jsonl');
+let enabled = process.env.WORMCLAUDE_LEARN !== '0'; // varsayılan açık
+let count = 0;
+try {
+    count = fs.readFileSync(FILE, 'utf8').split('\n').filter(Boolean).length;
+}
+catch { }
+export function isLearnEnabled() { return enabled; }
+export function setLearnEnabled(b) { enabled = b; }
+export function getLearnFile() { return FILE; }
+export function getLearnCount() { return count; }
+// Web-temelli bir Q&A çiftini eğitim datasına ekle (yerel + backend).
+export function recordLearned(instruction, response, sources = [], config) {
+    if (!enabled)
+        return false;
+    const instr = (instruction || '').trim();
+    const resp = (response || '').trim();
+    // Çöp/çok kısa kayıtları alma
+    if (instr.length < 3 || resp.length < 40)
+        return false;
+    if (/^\/[a-z]/i.test(instr))
+        return false; // slash komutu değil
+    const src = sources.slice(0, 8);
+    // 1) Yerel kopya (offline cache)
+    try {
+        fs.mkdirSync(DIR, { recursive: true });
+        fs.appendFileSync(FILE, JSON.stringify({ instruction: instr, response: resp, kat: 'web', len: resp.length, ts: Date.now(), sources: src }) + '\n');
+        count++;
+    }
+    catch { }
+    // 2) Backend'e gönder (merkezi korpus — fine-tune için). Fire-and-forget.
+    if (config && process.env.WORMCLAUDE_LEARN_REMOTE !== '0') {
+        fetch(`${config.baseUrl}/learn`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...(config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}) },
+            body: JSON.stringify({ instruction: instr, response: resp, sources: src, kat: 'web' }),
+            signal: AbortSignal.timeout(8000),
+        }).catch(() => { });
+    }
+    return true;
+}

package/dist/links.js

@@ -0,0 +1,31 @@
+// Tıklanabilir terminal linkleri (OSC8) — Claude Code ink/supports-hyperlinks.ts uyarlaması.
+// Destekleyen terminallerde metindeki URL'leri/markdown linkleri tıklanabilir yapar.
+const HYPERLINK_TERMINALS = ['ghostty', 'Hyper', 'kitty', 'alacritty', 'iTerm.app', 'iTerm2', 'WezTerm', 'vscode'];
+export function supportsHyperlinks() {
+    const env = process.env;
+    if (env.WORMCLAUDE_HYPERLINKS === '0')
+        return false;
+    if (env.WORMCLAUDE_HYPERLINKS === '1' || env.FORCE_HYPERLINK)
+        return true;
+    if (env.WT_SESSION)
+        return true; // Windows Terminal
+    if (env.TERM_PROGRAM === 'Apple_Terminal')
+        return false;
+    const tp = env.TERM_PROGRAM || '';
+    const lc = env.LC_TERMINAL || '';
+    if (HYPERLINK_TERMINALS.some((x) => tp.includes(x) || lc.includes(x)))
+        return true;
+    return false;
+}
+// OSC8: ESC ] 8 ;; URL ESC \  TEXT  ESC ] 8 ;; ESC \
+const ESC = '';
+export function osc8(url, text) {
+    return `${ESC}]8;;${url}${ESC}\\${text}${ESC}]8;;${ESC}\\`;
+}
+// Markdown [metin](url) ve düz URL'leri tek geçişte tıklanabilir yapar.
+// Alternation soldan eşleştiği için markdown linkin url'i ayrıca tekrar sarılmaz.
+export function linkify(s) {
+    if (!s || !supportsHyperlinks())
+        return s;
+    return s.replace(/\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)|(https?:\/\/[^\s<>"')\]]+)/g, (_m, mdText, mdUrl, bareUrl) => (mdUrl ? osc8(mdUrl, mdText) : osc8(bareUrl, bareUrl)));
+}

package/dist/mcp.js

@@ -0,0 +1,104 @@
+// MCP (Model Context Protocol) istemcisi — açık protokol, bulut-bağımsız.
+// .wormclaude/mcp.json'daki sunuculara bağlanır, araçlarını OpenAI function
+// şemasına çevirip modele sunar, çağrıları ilgili MCP sunucusuna yönlendirir.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+const servers = [];
+const toolMap = new Map();
+const CONFIG_PATH = path.join(process.cwd(), '.wormclaude', 'mcp.json');
+function sanitize(s) {
+    return s.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+export function getMcpConfigPath() { return CONFIG_PATH; }
+export function getMcpToolSchemas() {
+    return [...toolMap.values()].map((v) => v.schema);
+}
+export function getMcpServers() { return servers; }
+// .wormclaude/mcp.json formatı (Claude Code uyumlu):
+// { "mcpServers": {
+//     "filesystem": { "command": "npx", "args": ["-y","@modelcontextprotocol/server-filesystem","C:\\yol"] },
+//     "uzak":       { "type": "http", "url": "https://..." }
+// } }
+export async function connectMcpServers(timeoutMs = 15000) {
+    servers.length = 0;
+    toolMap.clear();
+    if (!fs.existsSync(CONFIG_PATH))
+        return servers;
+    let cfg;
+    try {
+        cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    }
+    catch (e) {
+        servers.push({ name: '(mcp.json)', status: 'error', toolNames: [], error: `parse: ${e?.message || e}` });
+        return servers;
+    }
+    const defs = cfg?.mcpServers || cfg?.servers || {};
+    for (const [name, raw] of Object.entries(defs)) {
+        const state = { name, status: 'connected', toolNames: [] };
+        try {
+            let transport;
+            if (raw.command) {
+                transport = new StdioClientTransport({
+                    command: raw.command,
+                    args: raw.args || [],
+                    env: { ...process.env, ...(raw.env || {}) },
+                });
+            }
+            else if (raw.url) {
+                const url = new URL(raw.url);
+                transport = raw.type === 'sse' ? new SSEClientTransport(url) : new StreamableHTTPClientTransport(url);
+            }
+            else {
+                throw new Error('config: "command" veya "url" gerekli');
+            }
+            const client = new Client({ name: 'wormclaude', version: '1.0.0' }, { capabilities: {} });
+            await Promise.race([
+                client.connect(transport),
+                new Promise((_, rej) => setTimeout(() => rej(new Error('bağlantı zaman aşımı')), timeoutMs)),
+            ]);
+            const { tools } = await client.listTools();
+            for (const t of tools) {
+                const prefixed = `mcp__${sanitize(name)}__${sanitize(t.name)}`;
+                toolMap.set(prefixed, {
+                    client,
+                    original: t.name,
+                    schema: {
+                        type: 'function',
+                        function: {
+                            name: prefixed,
+                            description: t.description || `${name}: ${t.name}`,
+                            parameters: t.inputSchema || { type: 'object', properties: {} },
+                        },
+                    },
+                });
+                state.toolNames.push(prefixed);
+            }
+        }
+        catch (e) {
+            state.status = 'error';
+            state.error = e?.message || String(e);
+        }
+        servers.push(state);
+    }
+    return servers;
+}
+export async function callMcpTool(name, args) {
+    const entry = toolMap.get(name);
+    if (!entry)
+        return { ok: false, output: `Bilinmeyen MCP aracı: ${name}` };
+    try {
+        const res = await entry.client.callTool({ name: entry.original, arguments: args || {} });
+        const content = Array.isArray(res?.content) ? res.content : [];
+        const text = content
+            .map((c) => (c?.type === 'text' ? c.text : c?.type === 'image' ? '[image]' : JSON.stringify(c)))
+            .join('\n');
+        return { ok: !res?.isError, output: (text || '(içerik yok)').slice(0, 20000) };
+    }
+    catch (e) {
+        return { ok: false, output: `MCP hata: ${e?.message || e}` };
+    }
+}

package/dist/memory.js

@@ -0,0 +1,135 @@
+// Otomatik hafıza — SessionMemory (sık, hafif) + autoDream (seyrek, derin) birleşik.
+// Tetik eşikleri ve kilit mekanizması Claude Code'dan uyarlandı.
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { completeText } from './agent.js';
+import { approxTokens } from './usage.js';
+import { tasks } from './tasks.js';
+// SessionMemory eşikleri (sessionMemoryUtils.ts'den)
+const MIN_INIT_TOKENS = 10000; // ilk tetik için minimum bağlam
+const MIN_TOKENS_BETWEEN = 5000; // güncellemeler arası bağlam büyümesi
+const MIN_TOOL_CALLS = 3; // güncellemeler arası min araç çağrısı
+// autoDream gate (config.ts'den)
+const DREAM_MIN_HOURS = 24;
+const SCAN_THROTTLE_MS = 10 * 60 * 1000;
+const LOCK_STALE_MS = 60 * 60 * 1000;
+const MEM_DIR = path.join(process.cwd(), '.wormclaude');
+const MEM_FILE = path.join(MEM_DIR, 'memory.md');
+const LOCK_FILE = path.join(MEM_DIR, '.consolidate-lock');
+let initialized = false;
+let inProgress = false;
+let tokensAtLast = 0;
+let toolCountAtLast = 0;
+function countToolCalls(history) {
+    let n = 0;
+    for (const m of history)
+        if (m.role === 'assistant' && Array.isArray(m.tool_calls))
+            n += m.tool_calls.length;
+    return n;
+}
+function lastAssistantHadTools(history) {
+    for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i].role === 'assistant')
+            return Array.isArray(history[i].tool_calls) && history[i].tool_calls.length > 0;
+    }
+    return false;
+}
+// SessionMemory tetik koşulu: bağlam yeterince büyüdü VE (yeterli araç çağrısı VEYA son tur araçsız)
+export function shouldExtract(history) {
+    if (inProgress)
+        return false;
+    const t = approxTokens(history);
+    if (!initialized) {
+        if (t < MIN_INIT_TOKENS)
+            return false;
+        initialized = true;
+    }
+    const grew = t - tokensAtLast >= MIN_TOKENS_BETWEEN;
+    if (!grew)
+        return false; // token eşiği HER ZAMAN zorunlu (CC notu)
+    const enoughTools = countToolCalls(history) - toolCountAtLast >= MIN_TOOL_CALLS;
+    return enoughTools || !lastAssistantHadTools(history);
+}
+// Arka planda hafızayı günceller (mevcut not + yeni konuşma → merge).
+export function triggerMemory(history, config) {
+    if (inProgress)
+        return;
+    inProgress = true;
+    tokensAtLast = approxTokens(history);
+    toolCountAtLast = countToolCalls(history);
+    const task = tasks.create('dream', 'oto-hafıza güncelleme');
+    const sys = history.find((m) => m.role === 'system');
+    const convo = history.filter((m) => m.role !== 'system');
+    (async () => {
+        try {
+            let prev = '';
+            try {
+                prev = fs.readFileSync(MEM_FILE, 'utf8');
+            }
+            catch { }
+            tasks.append(task.id, 'konuşmadan kalıcı bilgiler çıkarılıyor…\n');
+            const out = await completeText([
+                sys ?? { role: 'system', content: 'You maintain long-term memory.' },
+                ...convo,
+                {
+                    role: 'user',
+                    content: 'NOT: Bu mesaj konuşmanın parçası değil. Yukarıdaki konuşmadan kalıcı, faydalı bilgileri ' +
+                        '(kullanıcı tercihleri, kararlar, proje durumu, önemli dosyalar) çıkar ve aşağıdaki mevcut ' +
+                        'hafızaya MERGE et — kopya yazma, çelişeni güncelle. TÜM güncel hafızayı markdown madde imleriyle ' +
+                        'döndür. Göreli tarihleri mutlak yap.\n\nMEVCUT HAFIZA:\n' + (prev || '(boş)'),
+                },
+            ], config);
+            fs.mkdirSync(MEM_DIR, { recursive: true });
+            fs.writeFileSync(MEM_FILE, out);
+            tasks.append(task.id, `\nhafıza güncellendi: ${MEM_FILE} (${out.length} karakter)`);
+            tasks.finish(task.id, 'done');
+        }
+        catch (e) {
+            tasks.append(task.id, `\n[hata: ${e?.message || e}]`);
+            tasks.finish(task.id, 'error');
+        }
+        finally {
+            inProgress = false;
+        }
+    })();
+}
+// ── autoDream kilit (consolidationLock.ts'den) ────────────────────────────────
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Kilit alır; başka canlı process tutuyorsa null döner. Önceki mtime'ı döndürür (rollback için).
+export function tryAcquireDreamLock() {
+    try {
+        const st = fs.statSync(LOCK_FILE);
+        if (Date.now() - st.mtimeMs < LOCK_STALE_MS) {
+            const pid = parseInt(fs.readFileSync(LOCK_FILE, 'utf8'), 10);
+            if (pid && isProcessRunning(pid))
+                return null;
+        }
+        fs.mkdirSync(MEM_DIR, { recursive: true });
+        fs.writeFileSync(LOCK_FILE, String(process.pid));
+        return st.mtimeMs;
+    }
+    catch {
+        fs.mkdirSync(MEM_DIR, { recursive: true });
+        fs.writeFileSync(LOCK_FILE, String(process.pid));
+        return 0;
+    }
+}
+// autoDream zaman geçidi: son konsolidasyondan (lock mtime) bu yana ≥ DREAM_MIN_HOURS mı?
+export function dreamTimeGatePassed() {
+    try {
+        const st = fs.statSync(LOCK_FILE);
+        return (Date.now() - st.mtimeMs) / 3_600_000 >= DREAM_MIN_HOURS;
+    }
+    catch {
+        return true; // hiç konsolide edilmemiş
+    }
+}
+export function getMemoryPath() { return MEM_FILE; }