wormclaude 1.0.14 → 1.0.15

package/dist/agent.js

@@ -20,6 +20,7 @@ export async function runAgentLoop(opts) {
     const maxIters = opts.maxIters ?? 12;
     let finalText = '';
     let iter = 0;
+    let nudged = false;
     for (; iter < maxIters; iter++) {
         if (opts.signal?.aborted)
             break;
@@ -46,8 +47,16 @@ export async function runAgentLoop(opts) {
         messages.push(asMsg);
         if (assistantText.trim())
             finalText = assistantText.trim();
-        if (!toolCalls.length)
+        if (!toolCalls.length) {
+            // Nudge: model ne metin ne araç döndürdüyse bir kez "final sonucu ver" diye dürt.
+            if (!assistantText.trim() && !nudged) {
+                nudged = true;
+                messages.push({ role: 'user', content: 'Lütfen şimdi nihai sonucu metin olarak ver ve araç çağırmayı bırak.' });
+                continue;
+            }
             break;
+        }
+        nudged = false; // ilerleme oldu → nudge sıfırla
         // Paralel çalıştırma (salt-okunur araçlar eşzamanlı). Sonuçlar orijinal sırada.
         const results = await executeToolCalls(toolCalls, {
             onStart: (c) => opts.hooks?.onTool?.(c.name, undefined),

package/dist/api.js

@@ -2,6 +2,8 @@
 // Dayanıklılık: bağlantı kurulumunda exponential backoff + jitter retry.
 // Ölçüm: usage (token) bilgisini 'done' olayında döndürür (billing için).
 import { loadStored, DEFAULT_BASE_URL } from './auth.js';
+import { StreamingToolCallParser } from './streamparser.js';
+import { safeJsonStringify } from './safejson.js';
 export function loadConfig() {
     const stored = loadStored();
     return {
@@ -93,7 +95,7 @@ export async function* streamChat(messages, tools, config, signal) {
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let buf = '';
-    const toolAcc = {};
+    const toolParser = new StreamingToolCallParser();
     let usage;
     while (true) {
         if (signal?.aborted) {
@@ -147,17 +149,17 @@ export async function* streamChat(messages, tools, config, signal) {
             if (delta.tool_calls) {
                 for (const tc of delta.tool_calls) {
                     const idx = tc.index ?? 0;
-                    if (!toolAcc[idx])
-                        toolAcc[idx] = { id: tc.id || `call_${idx}`, name: '', args: '' };
-                    if (tc.id)
-                        toolAcc[idx].id = tc.id;
-                    if (tc.function?.name)
-                        toolAcc[idx].name += tc.function.name;
-                    if (tc.function?.arguments)
-                        toolAcc[idx].args += tc.function.arguments;
+                    toolParser.addChunk(idx, tc.function?.arguments || '', tc.id, tc.function?.name);
                 }
             }
         }
     }
-    yield { type: 'done', toolCalls: Object.values(toolAcc), usage };
+    // Tamamlanan çağrıları sağlam biçimde topla; args'ı GEÇERLİ JSON string olarak emit et
+    // (tools.ts tarafındaki JSON.parse artık asla patlamaz — onarım burada yapıldı).
+    const toolCalls = toolParser.getCompleted().map((c) => ({
+        id: c.id,
+        name: c.name,
+        args: safeJsonStringify(c.args),
+    }));
+    yield { type: 'done', toolCalls, usage };
 }

package/dist/auth.js

@@ -37,6 +37,16 @@ function apiOrigin(baseUrl) {
 }
 function openBrowser(url) {
     try {
+        // Güvenlik: yalnız http/https aç. (Windows 'start' rastgele şema/dosya açabilir; savunma.)
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            return;
+        }
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+            return;
         let child;
         if (process.platform === 'win32') {
             child = spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' });

package/dist/cli.js

@@ -6,6 +6,8 @@ import * as path from 'node:path';
 import { theme, VERSION } from './theme.js';
 import { loadConfig, streamChat } from './api.js';
 import { allToolSchemas, executeToolCalls, executeTool, toolLabel, setToolConfig } from './tools.js';
+import { sanitizeError, sanitizeOutput } from './errorsan.js';
+import { cleanModelText } from './textclean.js';
 import { summarizeTools } from './toolSummary.js';
 import { pickTipId, tipText } from './tips.js';
 import { t, cmdDesc, setLang, saveLang, loadLang, getLang } from './i18n.js';
@@ -535,13 +537,13 @@ function App() {
             for await (const ev of streamChat(historyRef.current, allToolSchemas(), config, ac.signal)) {
                 if (ev.type === 'text') {
                     assistantText += ev.text;
-                    setStreaming(assistantText);
+                    setStreaming(cleanModelText(assistantText));
                     setTokens(Math.round(assistantText.length / 4));
                 }
                 else if (ev.type === 'error') {
                     if (isContextError(ev.error))
                         gotCtxError = true;
-                    assistantText += `\n[hata: ${ev.error}]`;
+                    assistantText += `\n[hata: ${sanitizeError(ev.error)}]`;
                     setStreaming(assistantText);
                 }
                 else if (ev.type === 'done') {
@@ -550,6 +552,8 @@ function App() {
                 }
             }
             setStreaming('');
+            // Sızan özel-token / tool-call markup'ını bir kez temizle (hem geçmiş hem gösterim için).
+            assistantText = cleanModelText(assistantText);
             // Reactive compact: bağlam taştıysa bir kez özetle ve turu tekrar dene
             if (gotCtxError && !reactiveRetried) {
                 reactiveRetried = true;
@@ -613,7 +617,7 @@ function App() {
                 onResult: (c, _i, res) => {
                     if ((c.name === 'WebSearch' || c.name === 'WebFetch') && res.ok)
                         usedWeb = true;
-                    push({ kind: 'tool', label: toolLabel(c.name, res.args), result: res.output, ok: res.ok });
+                    push({ kind: 'tool', label: toolLabel(c.name, res.args), result: sanitizeOutput(res.output), ok: res.ok });
                 },
                 confirm: (c, args) => new Promise((resolve) => {
                     if (allowedToolsRef.current.has(c.name))

package/dist/errorsan.js

@@ -0,0 +1,94 @@
+// Hata/çıktı temizleme: (1) gizli anahtar redaksiyonu, (2) backend kimlik maskeleme (white-label),
+// (3) OpenAI-tarzı JSON hata ayrıştırma, (4) dostça timeout mesajı.
+// Gemini errorSanitizer (sadece provider-maskeleme) + errorHandler'dan uyarlandı; gerçek secret-redaction eklendi.
+const PRODUCT = 'WormClaude';
+// ── (1) Gizli anahtar redaksiyonu ─────────────────────────────────────────────
+// Yalnız NET secret desenleri — kullanıcının normal metnini bozmamak için dar tutuldu.
+const SECRET_PATTERNS = [
+    [/\bwc_live_[A-Za-z0-9]{6,}/g, 'wc_live_[REDACTED]'],
+    [/\bwc_sk_[A-Za-z0-9]{6,}/g, 'wc_sk_[REDACTED]'],
+    [/\bsk-[A-Za-z0-9_-]{16,}/g, 'sk-[REDACTED]'],
+    [/\bghp_[A-Za-z0-9]{20,}/g, 'ghp_[REDACTED]'],
+    [/\bAKIA[A-Z0-9]{16}\b/g, 'AKIA[REDACTED]'],
+    [/\b(Bearer)\s+[A-Za-z0-9._\-]{12,}/gi, '$1 [REDACTED]'],
+    // key/secret/token/password [:= veya boşluk] <değer>  (env dump, config echo)
+    [/\b(api[_-]?key|secret|token|password|passwd|vllm[_-]?key)\b(["']?\s*[:=\s]\s*["']?)([A-Za-z0-9._\-]{6,})/gi,
+        '$1$2[REDACTED]'],
+];
+// Agresif: çıplak uzun-hex anahtarlar (48+ hex). git SHA (40) ve kısa hash'leri KORUR.
+// SADECE hata mesajlarında kullanılır — tool çıktısında değil (git log SHA'larını bozmasın).
+const BARE_HEX = /\b[0-9a-f]{48,}\b/gi;
+export function redactSecrets(text, aggressive = false) {
+    if (!text)
+        return text;
+    let out = String(text);
+    for (const [re, rep] of SECRET_PATTERNS)
+        out = out.replace(re, rep);
+    if (aggressive)
+        out = out.replace(BARE_HEX, '[REDACTED]');
+    return out;
+}
+// ── (2) Backend kimlik maskeleme (white-label) ────────────────────────────────
+// SADECE backend-kaynaklı metne uygulanır (hata mesajları). Kullanıcının kendi içeriğine UYGULANMAZ
+// (ör. tool çıktısındaki "localhost" kullanıcının kendi dev sunucusu olabilir).
+const BACKEND_PATTERNS = [
+    [/\bQwen[0-9]?(?:\.[0-9]+)?-?[A-Za-z0-9.\-]*/gi, PRODUCT],
+    [/\bqwen[_-]?\w*/gi, PRODUCT],
+    [/\bvllm\b/gi, `${PRODUCT} engine`],
+    [/\bhermes\b/gi, `${PRODUCT}`],
+    [/\b127\.0\.0\.1(?::\d+)?/g, PRODUCT],
+    [/\b0\.0\.0\.0(?::\d+)?/g, PRODUCT],
+    [/\blocalhost:(?:8000|8001|8788)\b/gi, PRODUCT],
+];
+export function maskBackend(text) {
+    if (!text)
+        return text;
+    let out = String(text);
+    for (const [re, rep] of BACKEND_PATTERNS)
+        out = out.replace(re, rep);
+    return out;
+}
+// ── (3) OpenAI-tarzı JSON hata ayrıştırma ─────────────────────────────────────
+function parseApiError(text) {
+    const t = (text || '').trim();
+    // "HTTP 500: {...}" veya düz JSON gövde içinde {"error":{"message":...}}
+    const jsonStart = t.indexOf('{');
+    if (jsonStart === -1)
+        return text;
+    try {
+        const obj = JSON.parse(t.slice(jsonStart));
+        const msg = obj?.error?.message || obj?.message || obj?.detail;
+        if (typeof msg === 'string' && msg.trim()) {
+            const prefix = t.slice(0, jsonStart).trim();
+            return prefix ? `${prefix} ${msg}` : msg;
+        }
+    }
+    catch { /* JSON değil — olduğu gibi bırak */ }
+    return text;
+}
+// ── (4) Dostça timeout mesajı ─────────────────────────────────────────────────
+const TIMEOUT_HINTS = [
+    'timeout', 'timed out', 'connection timeout', 'read timeout',
+    'etimedout', 'esockettimedout', 'deadline exceeded', 'und_err_socket',
+];
+export function isTimeoutError(text) {
+    const t = (text || '').toLowerCase();
+    return TIMEOUT_HINTS.some((h) => t.includes(h));
+}
+function friendlyTimeout(text) {
+    return `${text}\n  • Girdiyi kısaltmayı veya bağlamı sadeleştirmeyi dene.\n  • Ağ bağlantını kontrol et.\n  • Sorun sürerse birkaç saniye sonra tekrar dene.`;
+}
+// ── Birleşik: kullanıcıya gösterilecek hata ───────────────────────────────────
+export function sanitizeError(input) {
+    let text = input instanceof Error ? input.message : String(input ?? '');
+    text = parseApiError(text);
+    text = maskBackend(text);
+    text = redactSecrets(text, true); // hata mesajı → agresif (çıplak hex dahil)
+    if (isTimeoutError(text))
+        text = friendlyTimeout(text);
+    return text.trim();
+}
+// Tool çıktısı için: yalnız gizli anahtar redaksiyonu (kimlik maskeleme YOK — kullanıcının kendi içeriği).
+export function sanitizeOutput(text) {
+    return redactSecrets(text);
+}

package/dist/memory.js

@@ -2,6 +2,7 @@
 // Tetik eşikleri ve kilit mekanizması Claude Code'dan uyarlandı.
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import * as os from 'node:os';
 import { completeText } from './agent.js';
 import { approxTokens } from './usage.js';
 import { tasks } from './tasks.js';
@@ -133,6 +134,46 @@ export function dreamTimeGatePassed() {
     }
 }
 export function getMemoryPath() { return MEM_FILE; }
+// ── Açık kayıt: save_memory tool'u (otomatik hafızayı tamamlar) ────────────────
+const MEMORY_HEADER = '## Eklenen Hatıralar';
+/**
+ * Modelin/kullanıcının açıkça istediği tek bir kalıcı bilgiyi hafıza dosyasına ekler.
+ * Otomatik konsolidasyondan bağımsız; "## Eklenen Hatıralar" başlığı altına "- <fact>" yazar.
+ * scope: 'project' → cwd/.wormclaude/memory.md (varsayılan), 'global' → ~/.wormclaude/memory.md.
+ */
+export function saveMemoryFact(fact, scope = 'project') {
+    const clean = String(fact || '').trim().replace(/^(-+\s*)+/, '').trim();
+    if (!clean)
+        throw new Error('boş hatıra');
+    const dir = scope === 'global'
+        ? path.join(os.homedir(), '.wormclaude')
+        : MEM_DIR;
+    const file = path.join(dir, 'memory.md');
+    fs.mkdirSync(dir, { recursive: true });
+    let content = '';
+    try {
+        content = fs.readFileSync(file, 'utf8');
+    }
+    catch { }
+    const item = `- ${clean}`;
+    const idx = content.indexOf(MEMORY_HEADER);
+    if (idx === -1) {
+        const sep = content.length === 0 ? '' : content.endsWith('\n') ? '\n' : '\n\n';
+        content += `${sep}${MEMORY_HEADER}\n${item}\n`;
+    }
+    else {
+        // Başlıktan sonraki bölümün sonuna ekle (sonraki ## başlığına kadar)
+        const start = idx + MEMORY_HEADER.length;
+        let end = content.indexOf('\n## ', start);
+        if (end === -1)
+            end = content.length;
+        const before = content.slice(0, end).replace(/\s+$/, '');
+        const after = content.slice(end);
+        content = `${before}\n${item}${after.startsWith('\n') ? '' : '\n'}${after}`;
+    }
+    fs.writeFileSync(file, content);
+    return file;
+}
 // Kalıcı hafızayı başlangıçta context'e yüklemek için oku.
 // .wormclaude/memory.md (oturumlar arası hafıza) + WORMCLAUDE.md (proje notu).
 export function loadMemoryContext() {

package/dist/safejson.js

@@ -0,0 +1,166 @@
+// Qwen-14B'nin bozuk JSON tool-call argümanlarını kurtarmak için dayanıklı JSON yardımcıları.
+// Bağımlılıksız (jsonrepair YOK) — elle onarım stratejileri. Gemini safeJsonParse + fixBooleanCasing'den
+// uyarlandı; WormClaude'a özel sadeleştirildi.
+/**
+ * Python-tarzı True/False/None'ı JSON karşılıklarına çevirir (özyinelemeli, string-güvenli).
+ * Qwen bazen `{"flag": True}` üretir → geçerli JSON değil.
+ */
+export function fixBooleanCasing(text) {
+    let out = '';
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            out += ch;
+            if (escape)
+                escape = false;
+            else if (ch === '\\')
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        // String dışında: Python literal'lerini kelime-sınırında değiştir
+        const rest = text.slice(i);
+        const m = /^(True|False|None)\b/.exec(rest);
+        if (m) {
+            out += m[1] === 'True' ? 'true' : m[1] === 'False' ? 'false' : 'null';
+            i += m[1].length - 1;
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+/** String dışındaki trailing virgülleri kaldırır: `{"a":1,}` → `{"a":1}` */
+function stripTrailingCommas(text) {
+    let out = '';
+    let inString = false;
+    let escape = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            out += ch;
+            if (escape)
+                escape = false;
+            else if (ch === '\\')
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === ',') {
+            // Sonraki anlamlı karakter } veya ] ise virgülü at
+            let j = i + 1;
+            while (j < text.length && /\s/.test(text[j]))
+                j++;
+            if (text[j] === '}' || text[j] === ']')
+                continue;
+        }
+        out += ch;
+    }
+    return out;
+}
+/** Açık kalan string/parantez/köşeli ayraçları kapatır (streaming kesintisi onarımı). */
+function closeOpenStructures(text) {
+    let inString = false;
+    let escape = false;
+    const stack = [];
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escape)
+                escape = false;
+            else if (ch === '\\')
+                escape = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '{')
+            stack.push('}');
+        else if (ch === '[')
+            stack.push(']');
+        else if (ch === '}' || ch === ']')
+            stack.pop();
+    }
+    let out = text;
+    if (inString)
+        out += '"';
+    while (stack.length)
+        out += stack.pop();
+    return out;
+}
+/**
+ * Bozuk/yarım JSON'u en iyi çabayla parse eder. Sırayla: düz parse → fixBooleanCasing →
+ * trailing-comma temizliği → açık yapıları kapatma. Hepsi başarısızsa fallback döner.
+ */
+export function safeJsonParse(text, fallback) {
+    if (text == null)
+        return fallback;
+    const raw = String(text).trim();
+    if (!raw)
+        return fallback;
+    // 1) Düz
+    try {
+        return JSON.parse(raw);
+    }
+    catch { }
+    // 2) Boolean casing
+    let repaired = fixBooleanCasing(raw);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch { }
+    // 3) Trailing virgüller
+    repaired = stripTrailingCommas(repaired);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch { }
+    // 4) Açık yapıları kapat
+    repaired = closeOpenStructures(repaired);
+    try {
+        return JSON.parse(repaired);
+    }
+    catch { }
+    // 5) Pes
+    return fallback;
+}
+/**
+ * Döngüsel referansları ve hata/undefined değerleri tolere ederek JSON üretir.
+ * Asla fırlatmaz; başarısızsa fallback string döner.
+ */
+export function safeJsonStringify(value, space, fallback = '"[unserializable]"') {
+    const seen = new WeakSet();
+    try {
+        return JSON.stringify(value, (_k, v) => {
+            if (typeof v === 'bigint')
+                return v.toString();
+            if (v instanceof Error)
+                return { name: v.name, message: v.message };
+            if (typeof v === 'object' && v !== null) {
+                if (seen.has(v))
+                    return '[Circular]';
+                seen.add(v);
+            }
+            return v;
+        }, space);
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/streamparser.js

@@ -0,0 +1,158 @@
+// Streaming tool-call delta'larını dayanıklı biçimde birleştirir.
+// Qwen-14B + vLLM(hermes) parçalı JSON arg, index çakışması, ID'siz devam chunk'ı üretebilir.
+// Gemini streamingToolCallParser'dan uyarlandı; bizim {index, id?, name?, argChunk} delta'mıza göre sade.
+import { safeJsonParse } from './safejson.js';
+export class StreamingToolCallParser {
+    buffers = new Map();
+    depths = new Map();
+    inStrings = new Map();
+    escapes = new Map();
+    meta = new Map();
+    idToIndex = new Map();
+    nextIndex = 0;
+    /**
+     * Bir delta chunk'ı ekler. index streaming yanıtından gelir (çakışabilir); id yeni çağrı başlangıcı.
+     * @returns chunk işlendikten sonra o index'te JSON tamamlandıysa parse edilmiş değer.
+     */
+    addChunk(index, chunk, id, name) {
+        let actual = index;
+        if (id) {
+            if (this.idToIndex.has(id)) {
+                actual = this.idToIndex.get(id);
+            }
+            else {
+                // Bu index'te FARKLI id'li, tamamlanmış bir çağrı varsa yeni slot bul
+                if (this.buffers.has(index)) {
+                    const buf = this.buffers.get(index);
+                    const depth = this.depths.get(index);
+                    const m = this.meta.get(index);
+                    if (buf.trim() && depth === 0 && m?.id && m.id !== id) {
+                        try {
+                            JSON.parse(buf);
+                            actual = this.findNextIndex();
+                        }
+                        catch { /* yarım → güvenle yeniden kullan */ }
+                    }
+                }
+                this.idToIndex.set(id, actual);
+            }
+        }
+        else if (this.buffers.has(index)) {
+            // ID'siz devam: bu index tamamlandıysa en son yarım çağrıya yönlendir
+            const buf = this.buffers.get(index);
+            const depth = this.depths.get(index);
+            if (depth === 0 && buf.trim()) {
+                try {
+                    JSON.parse(buf);
+                    actual = this.findMostRecentIncomplete();
+                }
+                catch {
+                    actual = index;
+                }
+            }
+        }
+        if (!this.buffers.has(actual)) {
+            this.buffers.set(actual, '');
+            this.depths.set(actual, 0);
+            this.inStrings.set(actual, false);
+            this.escapes.set(actual, false);
+            this.meta.set(actual, {});
+        }
+        const m = this.meta.get(actual);
+        if (id)
+            m.id = id;
+        if (name)
+            m.name = (m.name || '') + name;
+        const newBuffer = this.buffers.get(actual) + chunk;
+        this.buffers.set(actual, newBuffer);
+        // Derinlik takibi — sadece string DIŞINDAKİ ayraçları say
+        let depth = this.depths.get(actual);
+        let inString = this.inStrings.get(actual);
+        let escape = this.escapes.get(actual);
+        for (const ch of chunk) {
+            if (!inString) {
+                if (ch === '{' || ch === '[')
+                    depth++;
+                else if (ch === '}' || ch === ']')
+                    depth--;
+            }
+            if (ch === '"' && !escape)
+                inString = !inString;
+            escape = ch === '\\' && !escape;
+        }
+        this.depths.set(actual, depth);
+        this.inStrings.set(actual, inString);
+        this.escapes.set(actual, escape);
+        if (depth === 0 && newBuffer.trim().length > 0) {
+            try {
+                return { complete: true, value: JSON.parse(newBuffer) };
+            }
+            catch {
+                return { complete: false };
+            }
+        }
+        return { complete: false };
+    }
+    /** Stream bittiğinde (finish_reason) çağrılır. name'i olan ve buffer'ı dolu tüm çağrıları döndürür. */
+    getCompleted() {
+        const out = [];
+        for (const [index, buffer] of this.buffers.entries()) {
+            const m = this.meta.get(index);
+            if (!m?.name)
+                continue; // isimsiz parça → çağrı değil
+            // Boş buffer = argümansız tool (ör. {}). safeJsonParse onarım dener, başarısızsa {} fallback.
+            const args = buffer.trim() ? safeJsonParse(buffer, {}) : {};
+            out.push({ id: m.id || `call_${index}`, name: m.name, args, index });
+        }
+        return out;
+    }
+    reset() {
+        this.buffers.clear();
+        this.depths.clear();
+        this.inStrings.clear();
+        this.escapes.clear();
+        this.meta.clear();
+        this.idToIndex.clear();
+        this.nextIndex = 0;
+    }
+    findNextIndex() {
+        while (this.buffers.has(this.nextIndex)) {
+            const buf = this.buffers.get(this.nextIndex);
+            const depth = this.depths.get(this.nextIndex);
+            const m = this.meta.get(this.nextIndex);
+            if (!buf.trim() || depth > 0 || !m?.id)
+                return this.nextIndex;
+            try {
+                JSON.parse(buf);
+                if (depth === 0) {
+                    this.nextIndex++;
+                    continue;
+                }
+            }
+            catch {
+                return this.nextIndex;
+            }
+            this.nextIndex++;
+        }
+        return this.nextIndex++;
+    }
+    findMostRecentIncomplete() {
+        let maxIndex = -1;
+        for (const [index, buffer] of this.buffers.entries()) {
+            const depth = this.depths.get(index);
+            const m = this.meta.get(index);
+            if (m?.id && (depth > 0 || !buffer.trim())) {
+                maxIndex = Math.max(maxIndex, index);
+            }
+            else if (buffer.trim()) {
+                try {
+                    JSON.parse(buffer);
+                }
+                catch {
+                    maxIndex = Math.max(maxIndex, index);
+                }
+            }
+        }
+        return maxIndex >= 0 ? maxIndex : this.findNextIndex();
+    }
+}

package/dist/subagents.js

@@ -0,0 +1,119 @@
+// İsimli/uzman alt-ajan tanımları + kullanıcı-seviyesi loader.
+// Agent tool'u opsiyonel `subagent_type` ile çağrılınca buradan uzman prompt + tool-kısıtı çözülür.
+// Gemini builtin-agents + subagent-manager'dan uyarlandı; WormClaude güvenlik kimliğine göre.
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+// ── Gömülü uzman ajanlar ──────────────────────────────────────────────────────
+const BUILTINS = [
+    {
+        name: 'general-purpose',
+        description: 'Karmaşık soruları araştırma, kod arama ve çok adımlı görevler için genel amaçlı ajan.',
+        system: 'Sen bir WormClaude alt-ajanısın: tek bir görevi uçtan uca bitirmek için doğmuş otonom bir işçi. ' +
+            'İstenen neyse onu yap — fazlası değil, eksiği değil. Geniş arama için Grep/Glob, bilinen yol için Read kullan. ' +
+            'Gereksiz dosya YARATMA; *.md/README dosyalarını yalnız açıkça istenirse oluştur. ' +
+            'Bu görev dışında hafızan yok. Bitince yaptıklarının ve istenen sonuçların kısa, net bir raporunu döndür. ' +
+            'Yanıtta paylaştığın dosya yolları MUTLAK olmalı; göreli yol kullanma. Emoji kullanma.',
+    },
+    {
+        name: 'security-recon',
+        description: 'YETKİLİ güvenlik testlerinde keşif: port/servis/teknoloji tespiti, yüzey analizi, raporlama.',
+        system: 'Sen bir WormClaude güvenlik-keşif alt-ajanısın. SADECE yetkili/izinli hedeflerde çalış. ' +
+            'Görevin: pasif ve aktif keşif (port/servis tespiti, teknoloji parmak izi, dizin/endpoint yüzeyi, ' +
+            'sürüm tespiti) yapıp bulgularını yapılandırılmış bir rapor olarak döndürmek. ' +
+            'Yıkıcı işlem, gerçek istismar veya hizmet-dışı bırakma YAPMA — yalnız keşif ve analiz. ' +
+            'Bulguları önem derecesiyle (bilgi/düşük/orta/yüksek) sınıflandır. Komut çıktısını ham bırakma, yorumla. Emoji kullanma.',
+        tools: ['Bash', 'Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'TaskOutput'],
+    },
+    {
+        name: 'code-explorer',
+        description: 'Büyük kod tabanlarını haritalama: mimari, modül ilişkileri, giriş noktaları.',
+        system: 'Sen bir WormClaude kod-keşif alt-ajanısın. Görevin bir kod tabanını hızla haritalamak: ' +
+            'dizin yapısı, ana modüller, giriş noktaları, önemli soyutlamalar ve bağımlılıklar. ' +
+            'Grep/Glob ile geniş tara, Read ile kritik dosyaları incele. Dosya YARATMA/DEĞİŞTİRME. ' +
+            'Sonucu: kısa mimari özet + ilgili dosya yolları (MUTLAK) + kod parçaları olarak döndür. Emoji kullanma.',
+        tools: ['Grep', 'Glob', 'Read', 'TaskOutput'],
+    },
+];
+// ── Kullanıcı-seviyesi ajanlar: ~/.wormclaude/agents/*.md ─────────────────────
+function agentsDir() {
+    return path.join(os.homedir(), '.wormclaude', 'agents');
+}
+/** Minimal frontmatter ayrıştırma (yaml-parser gelene kadar; name/description/tools + body). */
+function parseAgentFile(content, fallbackName) {
+    const m = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/.exec(content);
+    if (!m)
+        return null;
+    const [, fm, body] = m;
+    const get = (key) => {
+        const r = new RegExp(`^${key}\\s*:\\s*(.+)$`, 'mi').exec(fm);
+        return r ? r[1].trim().replace(/^["']|["']$/g, '') : undefined;
+    };
+    const name = (get('name') || fallbackName).trim();
+    const description = get('description') || '';
+    const system = body.trim();
+    if (!name || !system)
+        return null;
+    // tools: [A, B] veya A,B
+    let tools;
+    const rawTools = get('tools');
+    if (rawTools) {
+        tools = rawTools.replace(/[\[\]]/g, '').split(',').map((s) => s.trim()).filter(Boolean);
+        if (!tools.length)
+            tools = undefined;
+    }
+    // İsim guard: rezerve/biçim
+    const RESERVED = new Set(['self', 'system', 'user', 'model', 'tool', 'config', 'default']);
+    if (!/^[a-zA-Z0-9_-]{2,50}$/.test(name) || RESERVED.has(name.toLowerCase()))
+        return null;
+    return { name, description, system, tools };
+}
+function loadUserAgents() {
+    try {
+        const dir = agentsDir();
+        if (!fs.existsSync(dir))
+            return [];
+        return fs.readdirSync(dir)
+            .filter((f) => f.endsWith('.md'))
+            .map((f) => {
+            try {
+                const def = parseAgentFile(fs.readFileSync(path.join(dir, f), 'utf8'), f.replace(/\.md$/, ''));
+                return def;
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((d) => d !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/** Ajanı isme göre çöz. Öncelik: kullanıcı dosyası > gömülü. Bulunamazsa null. */
+export function resolveSubagent(type) {
+    if (!type)
+        return null;
+    const t = type.trim().toLowerCase();
+    const user = loadUserAgents().find((a) => a.name.toLowerCase() === t);
+    if (user)
+        return user;
+    return BUILTINS.find((a) => a.name.toLowerCase() === t) || null;
+}
+/** Tüm kullanılabilir ajanları listele (kullanıcı dosyaları gömülüleri gölgeler). */
+export function listSubagents() {
+    const seen = new Set();
+    const out = [];
+    for (const a of [...loadUserAgents(), ...BUILTINS]) {
+        const k = a.name.toLowerCase();
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(a);
+    }
+    return out;
+}
+/** Agent tool açıklamasına eklenecek "kullanılabilir tipler" satırı. */
+export function subagentTypesHint() {
+    return listSubagents().map((a) => `- ${a.name}: ${a.description}`).join('\n');
+}

package/dist/textclean.js

@@ -0,0 +1,37 @@
+// Model metnindeki sızıntıları temizler: özel tokenlar + parçalı tool-call markup.
+// Qwen-14B + vLLM(hermes) bazen ham çıktıya kontrol token'ları veya tool-call etiketleri sızdırır.
+// ChatML / Qwen özel token'ları
+const SPECIAL_TOKENS = [
+    '<|endoftext|>', '<|im_start|>', '<|im_end|>', '<|im_sep|>',
+    '<|endofturn|>', '<|fim_prefix|>', '<|fim_middle|>', '<|fim_suffix|>',
+];
+// Hermes tool-call markup (metne sızarsa) — bloğun TAMAMINI kaldır.
+const TOOL_CALL_BLOCK = /<tool_call>[\s\S]*?<\/tool_call>/g;
+const TOOL_RESPONSE_BLOCK = /<tool_response>[\s\S]*?<\/tool_response>/g;
+// Açık kalan (kapanışı gelmemiş) tek etiketler
+const STRAY_TOOL_TAGS = /<\/?(tool_call|tool_response)>/g;
+/**
+ * Görüntülenecek/saklanacak model metnini temizler. İçeriği bozmadan yalnız
+ * sızan kontrol token'larını ve tool-call markup'ını çıkarır.
+ */
+export function cleanModelText(text) {
+    if (!text)
+        return text;
+    let out = text;
+    out = out.replace(TOOL_CALL_BLOCK, '');
+    out = out.replace(TOOL_RESPONSE_BLOCK, '');
+    out = out.replace(STRAY_TOOL_TAGS, '');
+    for (const tok of SPECIAL_TOKENS) {
+        if (out.includes(tok))
+            out = out.split(tok).join('');
+    }
+    return out;
+}
+/**
+ * Streaming sırasında güvenli temizlik: yalnız TAM özel-token'ları ve kapanmış blokları
+ * temizler — yarım gelen bir etiketi (ör. "<tool_") sonraki chunk'ı bekleyeceği için bırakır.
+ * Akan tamponun tamamına uygulanır (parçalı token'ı bölmemek için).
+ */
+export function cleanStreamingBuffer(buffer) {
+    return cleanModelText(buffer);
+}

package/dist/tools.js

@@ -8,6 +8,8 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { loadConfig } from './api.js';
 import { runAgentLoop } from './agent.js';
+import { resolveSubagent, subagentTypesHint } from './subagents.js';
+import { saveMemoryFact } from './memory.js';
 import { tasks } from './tasks.js';
 import { getMcpToolSchemas, callMcpTool } from './mcp.js';
 import { getSkills, getSkill, buildSkillPrompt } from './skills.js';
@@ -301,12 +303,13 @@ export const toolSchemas = [
         type: 'function',
         function: {
             name: 'Agent',
-            description: AGENT_DESCRIPTION,
+            description: AGENT_DESCRIPTION + '\n\nAvailable subagent_type values (specialized prompt + restricted tools):\n' + subagentTypesHint(),
             parameters: {
                 type: 'object',
                 properties: {
                     description: { type: 'string', description: 'A short (3-5 word) description of the task' },
                     prompt: { type: 'string', description: 'The detailed, self-contained task for the sub-agent to perform' },
+                    subagent_type: { type: 'string', description: 'Optional: specialized agent to use (e.g. general-purpose, security-recon, code-explorer). Selects a tailored system prompt and a restricted tool set. Omit for a general sub-agent.' },
                     run_in_background: { type: 'boolean', description: 'Run the sub-agent in the background and return a task id (default false)' },
                 },
                 required: ['description', 'prompt'],
@@ -327,6 +330,21 @@ export const toolSchemas = [
             },
         },
     },
+    {
+        type: 'function',
+        function: {
+            name: 'SaveMemory',
+            description: 'Save a single concise fact to long-term memory so it persists across sessions. Use when the user explicitly asks you to remember something, or when you detect a durable preference, decision, project convention, or constraint worth keeping. Keep the fact short and self-contained. Do NOT use for transient or session-only details.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    fact: { type: 'string', description: 'The specific, self-contained fact to remember (e.g. "User prefers Turkish responses", "Project uses pnpm not npm").' },
+                    scope: { type: 'string', enum: ['project', 'global'], description: 'project = this project only (default), global = all projects.' },
+                },
+                required: ['fact'],
+            },
+        },
+    },
     {
         type: 'function',
         function: {
@@ -540,6 +558,7 @@ const TOOL_META = {
     Scroll: { needsPermission: true, validate: (a) => (a && a.direction ? null : 'direction gerekli') },
     WebSearch: { readOnly: true, needsPermission: true, validate: (a) => (a && a.query ? null : 'query gerekli') },
     TodoWrite: { readOnly: true, validate: (a) => (a && Array.isArray(a.todos) ? null : 'todos dizisi gerekli') },
+    SaveMemory: { validate: (a) => (a && a.fact && String(a.fact).trim() ? null : 'fact gerekli') },
     PowerShell: { needsPermission: true, validate: (a) => (a && a.command ? null : 'command gerekli') },
     NotebookEdit: { needsPermission: true, validate: (a) => (a && a.notebook_path ? null : 'notebook_path gerekli') },
     REPL: { needsPermission: true, validate: (a) => (a && a.language && a.code ? null : 'language ve code gerekli') },
@@ -664,13 +683,53 @@ export async function executeToolCalls(calls, hooks) {
     return results;
 }
 // Alt-agent'a verilecek araç seti (özyineleme/iç içe agent engellenir).
-function subAgentTools() {
-    return allToolSchemas().filter((t) => t.function.name !== 'Agent' && t.function.name !== 'Skill');
+// allow verilirse yalnız o adlardaki araçlar bırakılır (uzman ajan tool-kısıtı).
+function subAgentTools(allow) {
+    let list = allToolSchemas().filter((t) => t.function.name !== 'Agent' && t.function.name !== 'Skill');
+    if (allow && allow.length) {
+        const set = new Set(allow);
+        const filtered = list.filter((t) => set.has(t.function.name));
+        if (filtered.length)
+            list = filtered; // boş kalırsa kısıtı yok say (güvenli geri dönüş)
+    }
+    return list;
 }
 const SUBAGENT_SYSTEM = 'You are a WormClaude sub-agent: an autonomous worker spawned to complete one specific task. ' +
     'Use your tools (Bash, Read, Write, Edit, Glob, Grep, WebFetch, TaskOutput) to do the work, ' +
     'then return a concise final report of what you did and any results requested. ' +
     'You have no memory beyond this task. Be thorough and finish the task end-to-end.';
+// Levenshtein mesafesi (küçük, dep'siz) — bilinmeyen tool adına en yakın öneriler.
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    if (!m)
+        return n;
+    if (!n)
+        return m;
+    let prev = Array.from({ length: n + 1 }, (_, i) => i);
+    let cur = new Array(n + 1);
+    for (let i = 1; i <= m; i++) {
+        cur[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+        }
+        [prev, cur] = [cur, prev];
+    }
+    return prev[n];
+}
+// Bilinmeyen tool adı için " Did you mean 'X'?" önerisi (en yakın ≤3, makul mesafe).
+function suggestTools(unknown) {
+    const names = allToolSchemas().map((t) => t.function.name);
+    const ranked = names
+        .map((n) => ({ n, d: levenshtein(unknown.toLowerCase(), n.toLowerCase()) }))
+        .filter((x) => x.d <= Math.max(3, Math.floor(unknown.length / 2)))
+        .sort((a, b) => a.d - b.d)
+        .slice(0, 3)
+        .map((x) => `"${x.n}"`);
+    if (!ranked.length)
+        return '';
+    return ranked.length > 1 ? ` Did you mean one of: ${ranked.join(', ')}?` : ` Did you mean ${ranked[0]}?`;
+}
 export function toolLabel(name, args) {
     try {
         if (name === 'Bash')
@@ -688,9 +747,11 @@ export function toolLabel(name, args) {
         if (name === 'WebFetch')
             return `WebFetch(${args.url})`;
         if (name === 'Agent')
-            return `Agent(${args.description || ''}${args.run_in_background ? ', bg' : ''})`;
+            return `Agent(${args.description || ''}${args.subagent_type ? ':' + args.subagent_type : ''}${args.run_in_background ? ', bg' : ''})`;
         if (name === 'TaskOutput')
             return `TaskOutput(${args.task_id})`;
+        if (name === 'SaveMemory')
+            return `SaveMemory(${String(args.fact || '').slice(0, 50)})`;
         if (name === 'Skill')
             return `Skill(${args.name})`;
         if (name === 'WebSearch')
@@ -755,9 +816,9 @@ function walk(dir, out, depth = 0) {
 function globToRegex(pattern) {
     let re = pattern
         .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*\*/g, '')
+        .replace(/\*\*/g, '\u0000')
         .replace(/\*/g, '[^/\\\\]*')
-        .replace(//g, '.*')
+        .replace(/\u0000/g, '.*')
         .replace(/\?/g, '.');
     return new RegExp(re + '$', 'i');
 }
@@ -839,8 +900,12 @@ export async function executeTool(name, args) {
             return { ok: true, output: (out || '(no output)').slice(0, 20000) };
         }
         if (name === 'Agent') {
+            // Uzman ajan seçimi: subagent_type verilirse özel prompt + tool-kısıtı uygulanır.
+            const def = resolveSubagent(args.subagent_type);
+            const sysPrompt = def ? def.system : SUBAGENT_SYSTEM;
+            const subTools = subAgentTools(def?.tools);
             const subMessages = [
-                { role: 'system', content: SUBAGENT_SYSTEM },
+                { role: 'system', content: sysPrompt },
                 { role: 'user', content: String(args.prompt || '') },
             ];
             if (args.run_in_background) {
@@ -850,7 +915,7 @@ export async function executeTool(name, args) {
                         const { finalText } = await runAgentLoop({
                             config: cfg(),
                             messages: subMessages,
-                            tools: subAgentTools(),
+                            tools: subTools,
                             executeTool,
                             hooks: {
                                 onText: (t) => tasks.append(task.id, t),
@@ -870,7 +935,7 @@ export async function executeTool(name, args) {
             const { finalText } = await runAgentLoop({
                 config: cfg(),
                 messages: subMessages,
-                tools: subAgentTools(),
+                tools: subTools,
                 executeTool,
             });
             return { ok: true, output: finalText || '(sub-agent returned no text)' };
@@ -882,6 +947,16 @@ export async function executeTool(name, args) {
             const body = t.output.slice(-9000) || '(no output yet)';
             return { ok: true, output: `[${t.id}] ${t.kind} · ${t.status} · ${t.label}\n\n${body}` };
         }
+        if (name === 'SaveMemory') {
+            try {
+                const scope = args.scope === 'global' ? 'global' : 'project';
+                const file = saveMemoryFact(String(args.fact || ''), scope);
+                return { ok: true, output: `Hatıra kaydedildi (${scope}): "${String(args.fact).trim()}" → ${file}` };
+            }
+            catch (e) {
+                return { ok: false, output: `Hatıra kaydedilemedi: ${e?.message || e}` };
+            }
+        }
         if (name === 'Read') {
             const fp = args.file_path;
             if (!fs.existsSync(fp))
@@ -1220,7 +1295,7 @@ export async function executeTool(name, args) {
         }
         if (name.startsWith('mcp__'))
             return await callMcpTool(name, args);
-        return { ok: false, output: `Unknown tool: ${name}` };
+        return { ok: false, output: `Unknown tool: ${name}.${suggestTools(name)} Use exactly the registered tool names.` };
     }
     catch (e) {
         return { ok: false, output: `Error: ${e?.message || String(e)}` };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wormclaude",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "WormClaude CLI - uncensored security+code assistant (ink TUI, Claude-style)",
   "type": "module",
   "bin": {