natureco-cli 5.63.0 → 5.64.1

package/src/commands/gateway-server.js

@@ -2,13 +2,75 @@ const chalk = require('chalk');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { spawn, execSync } = require('child_process');
+const { spawn, execSync, execFileSync } = require('child_process');
 const pino = require('pino');
 const { loadBaileys } = require('../utils/baileys');
 const { ApiError } = require('../utils/errors');
+const { ensurePendingPairing, isPaired } = require('../utils/pairing-store');
+const { ChannelAdapter, ChannelDeliveryManager } = require('../utils/channel-sdk');
+const { DeliveryStore } = require('../utils/delivery-store');
 
 const PID_FILE = path.join(os.homedir(), '.natureco', 'gateway.pid');
 const LOG_FILE = path.join(os.homedir(), '.natureco', 'gateway.log');
+const gatewayStartedAt = Date.now();
+const gatewayDeliveryManager = new ChannelDeliveryManager({ store: new DeliveryStore() });
+
+async function buildGatewayHealth(config = {}, manager = gatewayDeliveryManager) {
+  const configuredChannels = ['whatsapp', 'telegram', 'signal', 'discord', 'slack', 'irc', 'mattermost', 'imessage', 'sms']
+    .filter(name => Object.keys(config).some(key => key.toLowerCase().startsWith(name) && !!config[key]));
+  const adapterHealth = await manager.health();
+  const channelStates = Object.fromEntries(configuredChannels.map(name => {
+    const adapter = adapterHealth.find(item => item.channel === name);
+    return [name, adapter || { channel: name, state: 'configured', ok: null }];
+  }));
+  const metrics = manager.snapshotMetrics();
+  return {
+    ok: metrics.failed === 0 || metrics.delivered > 0,
+    status: metrics.failed > 0 ? 'degraded' : 'healthy',
+    uptimeSeconds: Math.floor((Date.now() - gatewayStartedAt) / 1000),
+    pid: process.pid,
+    channels: channelStates,
+    delivery: { ...metrics, deadLetters: manager.deadLetters.length },
+    timestamp: new Date().toISOString(),
+  };
+}
+
+function registerGatewayDeliveryAdapters(config, manager = gatewayDeliveryManager) {
+  const register = (name, send, health) => {
+    if (manager.adapters.has(name)) return;
+    manager.register(new ChannelAdapter({ name, send, health }));
+  };
+  register('whatsapp', async item => {
+    if (!global.whatsappSock) throw new Error('WhatsApp not connected');
+    const jid = `${String(item.target).replace(/[^\d]/g, '')}@s.whatsapp.net`;
+    return global.whatsappSock.sendMessage(jid, { text: String(item.payload.message) });
+  }, async () => ({ ok: !!global.whatsappSock }));
+  register('telegram', async item => {
+    if (!global.telegramBot) throw new Error('Telegram not connected');
+    return global.telegramBot.sendMessage(String(item.target), String(item.payload.message));
+  }, async () => ({ ok: !!global.telegramBot }));
+  register('signal', item => sendSignalMessage(config, item.target, item.payload.message), async () => ({ ok: !!global.signalProvider || !!config.signalHttpUrl }));
+  register('irc', async item => {
+    if (!global.ircClient?.isReady()) throw new Error('IRC not connected');
+    return sendIrcMessage(global.ircClient, item.target, item.payload.message);
+  }, async () => ({ ok: !!global.ircClient?.isReady() }));
+  register('mattermost', item => sendMattermostMessage(config, item.target, item.payload.message), async () => ({ ok: !!global.mattermostProvider }));
+  register('imessage', async item => {
+    if (!global.imessageProvider) throw new Error('iMessage not connected');
+    return sendImessage(global.imessageProvider.imsgPath, item.target, item.payload.message);
+  }, async () => ({ ok: !!global.imessageProvider }));
+  register('sms', item => sendSmsMessage(config, item.target, item.payload.message), async () => ({ ok: !!global.smsProvider }));
+  register('discord', async item => {
+    if (!global.discordClient) throw new Error('Discord not connected');
+    const channel = await global.discordClient.channels.fetch(String(item.target));
+    return channel.send(String(item.payload.message));
+  }, async () => ({ ok: !!global.discordClient }));
+  register('slack', async item => {
+    if (!global.slackClient) throw new Error('Slack not connected');
+    return global.slackClient.chat.postMessage({ channel: String(item.target), text: String(item.payload.message) });
+  }, async () => ({ ok: !!global.slackClient }));
+  return manager;
+}
 
 // `https` is used in the webhook delivery path (~line 570). The require was
 // missing; the module only worked because Node's CommonJS cache happens to
@@ -408,9 +470,14 @@ async function startWhatsAppProvider(sessionDir, config) {
         // Log incoming number
         log('whatsapp', `Incoming from: +${sender}, allowed: ${JSON.stringify(allowedNumbers)}`, 'gray');
         
-        // Access control - skip if fromMe + LID (own conversation)
-        if (!(msg.key.fromMe && isLID) && allowedNumbers.length > 0 && !allowedNumbers.some(n => numberMatches(n, sender))) {
-          log('whatsapp', `blocked message from +${sender} (not in allowed list)`, 'yellow');
+        // Pairing is the default. The owner's own LID conversation is trusted;
+        // every other sender must be allowlisted or explicitly paired.
+        const ownConversation = msg.key.fromMe && isLID;
+        const gate = ownConversation
+          ? { allowed: true, trusted: true, reason: 'owner' }
+          : channelGate(config, 'whatsapp', sender);
+        if (!gate.allowed) {
+          log('whatsapp', `blocked message from +${sender} (${gate.reason})`, 'yellow');
           continue;
         }
         
@@ -437,8 +504,7 @@ async function startWhatsAppProvider(sessionDir, config) {
         try {
           // v5.47 TEK BEYIN: allow-list'teki gonderen (veya sahibin kendi cihazi) =
           // guvenilir → terminaldekiyle ayni ajan. Aksi halde hafizasiz hafif yol.
-          const trusted = (msg.key.fromMe && isLID) ||
-            (allowedNumbers.length > 0 && allowedNumbers.some(n => numberMatches(n, sender)));
+          const trusted = gate.trusted;
           let reply = '';
 
           if (trusted) {
@@ -516,8 +582,11 @@ async function startDiscordProvider(config) {
     client.on(Events.MessageCreate, async (message) => {
       if (message.author.bot) return;
       const chatId = message.channel.id;
-      const allowedChats = config.discordAllowedChats || [];
-      if (allowedChats.length > 0 && !allowedChats.includes(chatId)) return;
+      const gate = channelGate(config, 'discord', String(message.author.id || chatId));
+      if (!gate.allowed) {
+        log('discord', `blocked message from ${message.author.id} (${gate.reason})`, 'yellow');
+        return;
+      }
 
       try {
         const response = await callProviderForGateway(config, message.content, {
@@ -546,13 +615,19 @@ async function startDiscordProvider(config) {
 // yetkisiz/yabancı gönderene kişisel hafıza sızabiliyordu. channelGate: (1) allow-list
 // kuruluysa yetkisiz göndereni ENGELLE; (2) allow-list kurulu DEĞİLSE yanıt ver ama
 // kişisel hafızayı ENJEKTE ETME (trusted=false) — böylece anonim kanaldan hafıza sızmaz.
-function channelGate(config, channel, senderId) {
+function channelGate(config, channel, senderId, pairing = { isPaired, ensurePendingPairing }) {
   const allow = config[`${channel}AllowedChats`] || config[`${channel}AllowedNumbers`] || config[`${channel}AllowedUsers`] || [];
-  if (!Array.isArray(allow) || allow.length === 0) {
-    return { allowed: true, trusted: false };
+  const allowlisted = Array.isArray(allow) && allow.map(String).includes(String(senderId));
+  if (allowlisted) return { allowed: true, trusted: true, reason: 'allowlist' };
+
+  const policy = config[`${channel}DmPolicy`] || 'pairing';
+  if (policy === 'open') return { allowed: true, trusted: false, reason: 'open' };
+  if (policy === 'disabled' || policy === 'allowlist') {
+    return { allowed: false, trusted: false, reason: policy };
   }
-  const ok = allow.map(String).includes(String(senderId));
-  return { allowed: ok, trusted: ok };
+  if (pairing.isPaired(channel, senderId)) return { allowed: true, trusted: true, reason: 'paired' };
+  const pending = pairing.ensurePendingPairing(channel, senderId);
+  return { allowed: false, trusted: false, reason: 'pairing-required', pairingId: pending.id };
 }
 
 async function startSlackProvider(config) {
@@ -1500,7 +1575,7 @@ function startImessagePollingFallback(imsgPath, config) {
     try {
       const args = ['history', '--format', 'json', '--limit', '10'];
       if (lastRowId) args.push('--since-rowid', String(lastRowId));
-      const result = execSync(`"${imsgPath}" ${args.join(' ')} 2>/dev/null`, {
+      const result = execFileSync(imsgPath, args, {
         encoding: 'utf-8', timeout: 10000, stdio: 'pipe',
       });
       const lines = result.trim().split('\n').filter(Boolean);
@@ -1519,6 +1594,13 @@ function startImessagePollingFallback(imsgPath, config) {
   log('imessage', 'polling started (15s interval, history fallback)', 'green');
 }
 
+function sendImessage(imsgPath, target, text) {
+  return execFileSync(imsgPath, ['send', '--to', String(target), '--text', String(text)], {
+    timeout: 15000,
+    stdio: 'pipe',
+  });
+}
+
 function findImsgBin() {
   const config = require('../utils/config').getConfig();
   if (config.imessageCliPath && fs.existsSync(config.imessageCliPath)) return config.imessageCliPath;
@@ -1601,9 +1683,7 @@ async function processImessageMessage(msg, config) {
     }
 
     if (reply) {
-      execSync(`${global.imessageProvider.imsgPath} send --to "${sender}" --text "${reply.replace(/"/g, '\\"')}" 2>/dev/null`, {
-        timeout: 15000, stdio: 'pipe',
-      });
+      sendImessage(global.imessageProvider.imsgPath, sender, reply);
       log('imessage', `Reply sent to ${sender} (${reply.length} chars)`, 'green');
 
       // v5.6.40: Track outgoing message for loop prevention
@@ -1805,7 +1885,7 @@ function startHttpServer() {
   const server = http.createServer(async (req, res) => {
     // CORS headers
     res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
     
     if (req.method === 'OPTIONS') {
@@ -1813,6 +1893,14 @@ function startHttpServer() {
       res.end();
       return;
     }
+
+    if (req.method === 'GET' && (req.url === '/health' || req.url === '/metrics')) {
+      const { getConfig } = require('../utils/config');
+      const snapshot = await buildGatewayHealth(getConfig(), gatewayDeliveryManager);
+      res.writeHead(snapshot.status === 'healthy' ? 200 : 503, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
+      res.end(JSON.stringify(req.url === '/health' ? snapshot : snapshot.delivery));
+      return;
+    }
     
     if (req.method === 'POST' && req.url === '/webhooks/sms') {
       // Twilio SMS webhook handler
@@ -1857,6 +1945,23 @@ function startHttpServer() {
             res.end(JSON.stringify({ error: 'Missing required fields: channel, target, message' }));
             return;
           }
+
+          const cfg = require('../utils/config').getConfig();
+          registerGatewayDeliveryAdapters(cfg, gatewayDeliveryManager);
+          if (gatewayDeliveryManager.adapters.has(channel)) {
+            const queued = gatewayDeliveryManager.enqueue(channel, target, { message }, { idempotencyKey: req.headers['idempotency-key'] });
+            if (queued.duplicate) {
+              res.writeHead(200, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ success: true, duplicate: true, deliveryId: queued.id }));
+              return;
+            }
+            const [delivery] = await gatewayDeliveryManager.drain();
+            res.writeHead(delivery.ok ? 200 : 503, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(delivery.ok
+              ? { success: true, channel, target, deliveryId: delivery.id, attempts: delivery.attempts }
+              : { success: false, channel, target, deliveryId: delivery.id, error: delivery.error }));
+            return;
+          }
           
           if (channel === 'whatsapp') {
             if (!global.whatsappSock) {
@@ -1938,9 +2043,7 @@ function startHttpServer() {
               return;
             }
             try {
-              execSync(`${global.imessageProvider.imsgPath} send --to "${target.replace(/"/g, '\\"')}" --text "${message.replace(/"/g, '\\"')}" 2>/dev/null`, {
-                timeout: 15000, stdio: 'pipe',
-              });
+              sendImessage(global.imessageProvider.imsgPath, target, message);
               log('http', `iMessage sent to ${target}`, 'green');
               res.writeHead(200, { 'Content-Type': 'application/json' });
               res.end(JSON.stringify({ success: true, channel: 'imessage', target }));
@@ -2133,9 +2236,7 @@ function startCronJobs(config) {
                 log('cron', 'iMessage not connected, skipping', 'red');
                 return;
               }
-              execSync(`${global.imessageProvider.imsgPath} send --to "${cronJob.target.replace(/"/g, '\\"')}" --text "${reply.replace(/"/g, '\\"')}" 2>/dev/null`, {
-                timeout: 15000, stdio: 'pipe',
-              });
+              sendImessage(global.imessageProvider.imsgPath, cronJob.target, reply);
               log('cron', `Sent to iMessage: ${cronJob.target}`, 'green');
             } else if (cronJob.action === 'sms') {
               if (!global.smsProvider) {
@@ -2267,3 +2368,6 @@ if (require.main === module || process.argv.includes('--gateway-worker')) {
 module.exports = gatewayServer;
 // v5.43: test için — kanal gönderen doğrulaması + hafıza izolasyonu (Madde 7)
 module.exports.channelGate = channelGate;
+module.exports.buildGatewayHealth = buildGatewayHealth;
+module.exports.gatewayDeliveryManager = gatewayDeliveryManager;
+module.exports.registerGatewayDeliveryAdapters = registerGatewayDeliveryAdapters;

package/src/commands/git.js

@@ -1,4 +1,4 @@
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 const inquirer = require('../utils/inquirer-wrapper');
 const chalk = require('chalk');
 const { getApiKey } = require('../utils/config');
@@ -111,7 +111,7 @@ async function gitCommit() {
     
     if (answer.confirm) {
       try {
-        execSync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, { stdio: 'inherit' });
+        execFileSync('git', ['commit', '-m', commitMessage], { stdio: 'inherit' });
         console.log(chalk.green('\n✅ Committed successfully\n'));
       } catch (err) {
         console.log(chalk.red('\n❌ Commit failed\n'));

package/src/commands/help.js

@@ -12,6 +12,15 @@ const { getLang } = require('../utils/i18n');
 
 const L = (tr, en) => (getLang() === 'en' ? en : tr);
 
+function providerHostname(providerUrl) {
+  if (!providerUrl) return '';
+  try {
+    return new URL(providerUrl).hostname;
+  } catch {
+    return String(providerUrl).replace(/^https?:\/\//i, '').split('/')[0];
+  }
+}
+
 function help() {
   const config = getConfig() || {};
   const version = require('../../package.json').version;
@@ -203,7 +212,7 @@ function help() {
       tui.styled('  ╭' + '─'.repeat(cardW) + '╮', { color: tui.PALETTE.border }),
     ];
     if (config.providerUrl) {
-      const provider = config.providerUrl.replace('https?:\/\/', '').split('/')[0];
+      const provider = providerHostname(config.providerUrl);
       cardLines.push(tui.styled('  │ ', { color: tui.PALETTE.border }) + tui.C.muted('Provider   ') + tui.styled(provider.padEnd(38), { color: tui.PALETTE.text, bold: true }) + tui.styled(' │', { color: tui.PALETTE.border }));
     }
     if (config.providerModel) {
@@ -228,3 +237,4 @@ function help() {
 }
 
 module.exports = help;
+module.exports.providerHostname = providerHostname;

package/src/commands/pairing.js

@@ -1,25 +1,5 @@
 const chalk = require('chalk');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const PAIRINGS_FILE = path.join(os.homedir(), '.natureco', 'pairings.json');
-
-function loadPairings() {
-  if (!fs.existsSync(PAIRINGS_FILE)) return [];
-  try { return JSON.parse(fs.readFileSync(PAIRINGS_FILE, 'utf8')); }
-  catch { return []; }
-}
-
-function savePairings(pairings) {
-  const dir = path.dirname(PAIRINGS_FILE);
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(PAIRINGS_FILE, JSON.stringify(pairings, null, 2), 'utf8');
-}
-
-function genId() {
-  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8).toUpperCase();
-}
+const { loadPairings, savePairings, genCode } = require('../utils/pairing-store');
 
 function pairing(args) {
   const [action, ...params] = args || [];
@@ -84,7 +64,7 @@ function cmdReject(id) {
 }
 
 function cmdGenerate() {
-  const code = genId();
+  const code = genCode();
   const pairings = loadPairings();
 
   const entry = {

package/src/commands/repl.js

@@ -56,7 +56,7 @@ const { createPasteSafeInput, createOutputFilter, enableBracketedPaste, disableB
 const { getMemoryStore } = require('../utils/memory-store');
 const { buildSkillIndex } = require('../utils/skill-index');
 const { buildTiers, assemble, discoverProjectRules } = require('../utils/system-prompt');
-const { ToolGuardrails } = require('../utils/tool-guardrails');
+const { AgentCore } = require('../utils/agent-core');
 
 // v5.4.6: Model adi sizintisini engelle — global'e ata, callback'lerden erisebilir olsun
 const MODEL_NAMES_TO_HIDE = ['MiniMax-M2.5', 'MiniMaxM2.5', 'minimaxm25', 'Claude-3', 'GPT-4', 'ChatGPT'];
@@ -128,7 +128,8 @@ function rebuildSystemPrompt(opts) {
 }
 
 // ── Tool Guardrails instance (Hermes-style) ─────────────────────────────
-const guardrails = new ToolGuardrails();
+const agentCore = new AgentCore({ maxIterations: 10 });
+const guardrails = agentCore.guardrails;
 
 // CLI komutları (REPL içinden çalıştırılabilir)
 const CLI_COMMANDS = {
@@ -835,8 +836,9 @@ async function processToolCalls(toolCalls, onToolCall, onAsk) {
   const results = [];
 
   // Parse all tool calls first
-  const parsed = toolCalls.map(tc => {
-    const name = tc.function?.name || tc.name;
+  const parsed = agentCore.parseToolCalls(toolCalls).map(call => {
+    const tc = call.original;
+    const name = tc.function?.name || tc.name;
     const argsStr = tc.function?.arguments || tc.args || '{}';
     const id = tc.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
     let args;
@@ -845,11 +847,11 @@ async function processToolCalls(toolCalls, onToolCall, onAsk) {
     } catch (e) {
       args = { _parse_error: e.message, _raw: argsStr };
     }
-    return { name, args, id };
+    return { name, args, id, parseError: call.parseError };
   });
 
   // Filter out blocked tools via guardrails
-  guardrails.startIteration();
+  agentCore.startIteration();
   const blocked = parsed.filter(p => {
     const check = guardrails.check(p.name, p.args);
     if (check.blocked) {

package/src/tools/agentic-runner.js

@@ -15,6 +15,8 @@
  * bu modda KAPALIDIR (onay katmanini atlamamak icin).
  */
 const path = require('path');
+const { executeThroughGateway } = require('../utils/tool-execution-gateway');
+const { assessToolPath } = require('../utils/tool-path-policy');
 const os = require('os');
 
 // Agentic dongude izin verilen araclar. bash BURADA ama guvenli: bash.js kendi
@@ -64,21 +66,9 @@ function expandHome(p) {
 // Hassas dosya yolu koruması (safe modda). Coding-agent proje dosyalarina serbest erisir
 // ama kimlik/secret yollari prompt-injection ile suistimal edilebilir (SSH backdoor,
 // credential sizintisi). Full modda (sahibin opt-in'i) bypass edilir.
-const SENSITIVE_READ = [
-  /(^|[\\/])\.ssh[\\/]/i, /id_rsa|id_ed25519|id_ecdsa|id_dsa/i, /\.pem$|\.ppk$|\.key$/i,
-  /(^|[\\/])\.aws[\\/]/i, /gcloud[\\/].*(credential|token)/i, /(^|[\\/])\.npmrc$/i,
-  /(^|[\\/])\.git-credentials$/i, /\.natureco[\\/]config\.json$/i, /(^|[\\/])\.netrc$/i,
-];
-const SENSITIVE_WRITE = [
-  /(^|[\\/])\.ssh[\\/]/i,                 // authorized_keys/config yazma = backdoor
-  /^\/(etc|usr|bin|sbin|boot|sys)[\\/]/i, // mutlak sistem yollari
-  /(^|[\\/])etc[\\/](passwd|shadow|sudoers|hosts|crontab|ssh)/i, // goreceli traversal dahil (../../etc/shadow)
-  /System32[\\/]drivers[\\/]etc/i, /\.aws[\\/]credentials/i,
-];
 function sensitivePathBlocked(p, mode) {
-  const s = String(p || '');
-  const pats = mode === 'write' ? SENSITIVE_WRITE : SENSITIVE_READ;
-  return pats.some((re) => re.test(s));
+  const toolName = mode === 'write' ? 'write_file' : 'read_file';
+  return !assessToolPath(toolName, { path: p }).allowed;
 }
 
 // Ajanin urettigi komutlar icin ekstra koruma. bash.js kendi politikasini uygular
@@ -315,19 +305,34 @@ async function executeCall(call, opts = {}) {
   let files = call.args && call.args.files;
   if (typeof files === 'string') { try { files = JSON.parse(files); } catch { files = null; } }
   if (Array.isArray(files) && (/bulk/i.test(rawTool) || /file/i.test(rawTool) || norm === 'write_file')) {
+    // Bulk writes are still write_file operations. Apply the same allowlist and
+    // protected-path policy before loading or executing the tool; otherwise the
+    // early return below would bypass the normal checks later in this function.
+    if (!opts.execFull && !allowed.has('write_file')) {
+      records.push({ tool: rawTool, status: 'error', error: 'Guvenli modda write_file kapali' });
+      return { records, feedback: `${rawTool}: guvenli modda write_file izni yok.` };
+    }
     let wf;
     try { wf = loadTool('write_file'); } catch { wf = null; }
     for (const f of files) {
       if (!wf || !f || !f.path) { records.push({ tool: 'write_file', status: 'error', error: 'gecersiz dosya girisi' }); feedbacks.push('write_file HATA: gecersiz giris'); continue; }
-      try {
-        const res = await wf.execute({ path: expandHome(f.path), content: f.content != null ? String(f.content) : '' });
-        const ok = res && res.success !== false;
-        records.push({ tool: 'write_file', status: ok ? 'done' : 'error', args: { path: f.path }, result: res, error: ok ? undefined : (res && res.error) });
-        feedbacks.push(ok ? `write_file OK: ${res.path || f.path} (${res.size != null ? res.size : '?'} bytes)` : `write_file HATA: ${res && res.error}`);
-      } catch (e) {
-        records.push({ tool: 'write_file', status: 'error', args: { path: f.path }, error: e.message });
-        feedbacks.push(`write_file HATA: ${e.message}`);
+      const targetPath = expandHome(String(f.path).trim());
+      if (!opts.execFull && sensitivePathBlocked(targetPath, 'write')) {
+        records.push({ tool: 'write_file', status: 'error', args: { path: targetPath }, error: 'Hassas dosya yolu (guvenli modda engellendi)' });
+        feedbacks.push(`write_file: "${targetPath}" hassas bir yol oldugu icin CALISTIRILMADI.`);
+        continue;
       }
+      const res = await executeThroughGateway({
+        toolName: 'write_file',
+        args: { path: targetPath, content: f.content != null ? String(f.content) : '' },
+        resolveTool: () => wf,
+        normalizeSuccess: value => value,
+        normalizeError: error => ({ success: false, error }),
+        allowSensitivePaths: !!opts.execFull,
+      });
+      const ok = res && res.success !== false;
+      records.push({ tool: 'write_file', status: ok ? 'done' : 'error', args: { path: targetPath }, result: res, error: ok ? undefined : (res && res.error) });
+      feedbacks.push(ok ? `write_file OK: ${res.path || targetPath} (${res.size != null ? res.size : '?'} bytes)` : `write_file HATA: ${res && res.error}`);
     }
     return { records, feedback: feedbacks.join('\n') };
   }
@@ -384,17 +389,20 @@ async function executeCall(call, opts = {}) {
     records.push({ tool: norm, status: 'error', error: 'execute yok' });
     return { records, feedback: `${norm} HATA: execute fonksiyonu yok` };
   }
-  try {
-    const res = await fn(args);
-    const ok = typeof res === 'string' ? true : (res && res.success !== false);
-    const status = ok ? 'done' : 'error';
-    const feedback = buildFeedback(norm, res);
-    records.push({ tool: norm, status, args: sanitizeArgs(args), result: res });
-    return { records, feedback };
-  } catch (e) {
-    records.push({ tool: norm, status: 'error', args: sanitizeArgs(args), error: e.message });
-    return { records, feedback: `${norm} HATA: ${e.message}` };
-  }
+  const res = await executeThroughGateway({
+    toolName: norm,
+    args,
+    resolveTool: () => mod,
+    execute: fn,
+    normalizeSuccess: value => value,
+    normalizeError: error => ({ success: false, error }),
+    allowSensitivePaths: !!opts.execFull,
+  });
+  const ok = typeof res === 'string' ? true : (res && res.success !== false);
+  const status = ok ? 'done' : 'error';
+  const feedback = buildFeedback(norm, res);
+  records.push({ tool: norm, status, args: sanitizeArgs(args), result: res, error: ok ? undefined : res.error });
+  return { records, feedback };
 }
 
 /**

package/src/tools/memory_write.js

@@ -9,6 +9,7 @@ const fs = require("fs");
 const path = require("path");
 const os = require("os");
 const { writeJsonAtomicSync, readJsonSafeSync } = require("../utils/atomic-file");
+const { createMemoryRecord, resolveConflict, factKey } = require("../utils/memory-record");
 
 const MEMORY_DIR = path.join(os.homedir(), ".natureco", "memory");
 
@@ -131,7 +132,7 @@ function verifyMemoryWrite(username, expectedFact, expectedBotName) {
 }
 
 
-function addMemory({ username, fact, score = 5, category = "general", botName, nickname, name }) {
+function addMemory({ username, fact, score = 5, category = "general", botName, nickname, name, source = "tool", confidence = 0.5, ttlMs, userConfirmed = false }) {
   // Username yoksa ve 'name' parametresi varsa, onu username olarak kullan
   // (hitap bicimi icin)
   const effectiveUsername = username || (name && name.toLowerCase()) || 'default';
@@ -149,18 +150,17 @@ function addMemory({ username, fact, score = 5, category = "general", botName, n
 
   if (fact) {
     // duplicate kontrol
-    const existing = memory.facts.find(f => (f.value || f).toLowerCase() === fact.toLowerCase());
+    const incoming = createMemoryRecord({ value: fact, score, category, source, confidence, ttlMs, userConfirmed, verified: true });
+    const key = factKey(fact, category);
+    const existing = memory.facts.find(f => factKey(f.value || f, f.category || category) === key);
     if (existing) {
-      existing.score = Math.min(10, (existing.score || 5) + 2);
-      existing.updatedAt = new Date().toISOString();
+      const sameValue = String(existing.value || existing).toLowerCase() === fact.toLowerCase();
+      const previousScore = existing.score || 5;
+      const resolved = resolveConflict(existing, incoming);
+      Object.assign(existing, resolved.winner);
+      if (sameValue) existing.score = Math.min(10, previousScore + 2);
     } else {
-      memory.facts.push({
-        value: fact,
-        score,
-        category,
-        updatedAt: new Date().toISOString(),
-        createdAt: new Date().toISOString(),
-      });
+      memory.facts.push(incoming);
     }
     // Limit'i ZIM push'tan sonra uygula → yeni eklenen fact düşürülmez.
     memory = enforceFactLimit(memory, { recentValue: fact });
@@ -236,6 +236,10 @@ module.exports = {
       fact: { type: "string", description: 'Yeni fact (ornek: "Kullanici kahve seviyor", "Istanbul\'da yasiyor")' },
       score: { type: "number", description: "Onem derecesi 1-10 (default 5)" },
       category: { type: "string", description: "Kategori: personal, preference, work, hobby, fact (default general)" },
+      source: { type: "string", description: "Bilginin kaynağı (user, tool, import, inference)" },
+      confidence: { type: "number", description: "Güven puanı 0-1" },
+      ttlMs: { type: "number", description: "İsteğe bağlı yaşam süresi (milisaniye)" },
+      userConfirmed: { type: "boolean", description: "Kullanıcı tarafından açıkça doğrulandı mı" },
       botName: { type: "string", description: "Bot adini degistir (memory.botName)" },
       nickname: { type: "string", description: "Kullanici nickname'i" },
       name: { type: "string", description: "Kullanici gercek adi" },
@@ -249,4 +253,4 @@ module.exports = {
     if (action === "show") return showMemory(params);
     return addMemory(params);
   },
-};
+};

package/src/tools/structural_patch.js

@@ -0,0 +1,25 @@
+const { StructuralPatchEngine } = require('../utils/structural-patch');
+const engine = new StructuralPatchEngine();
+
+module.exports = {
+  name: 'structural_patch',
+  description: 'Apply conflict-safe anchored text patches with preview and rollback support.',
+  inputSchema: {
+    type: 'object', required: ['action'],
+    properties: {
+      action: { type: 'string', enum: ['preview', 'apply', 'rollback'] },
+      path: { type: 'string' }, expectedHash: { type: 'string' }, patchId: { type: 'string' }, dryRun: { type: 'boolean' },
+      operations: { type: 'array', items: { type: 'object', required: ['search'], properties: {
+        search: { type: 'string' }, replace: { type: 'string' }, replaceAll: { type: 'boolean' },
+      } } },
+    },
+  },
+  async execute(params) {
+    if (params.action === 'rollback') return engine.rollback(params.patchId);
+    if (!params.path) return { success: false, error: 'path is required' };
+    const result = params.action === 'preview'
+      ? engine.preview(params.path, params.operations, { expectedHash: params.expectedHash, dryRun: true })
+      : engine.apply(params.path, params.operations, { expectedHash: params.expectedHash, dryRun: params.dryRun });
+    return result.ok ? { success: true, ...result } : { success: false, ...result };
+  },
+};

package/src/tools/workflow.js

@@ -1,6 +1,7 @@
 const https = require('https');
 const fs = require('fs');
-const path = require('path');
+const path = require('path');
+const { executeThroughGateway } = require('../utils/tool-execution-gateway');
 const os = require('os');
 
 const WORKFLOW_DIR = path.join(os.homedir(), '.natureco', 'workflows');
@@ -517,7 +518,14 @@ async function workflow(params) {
           const toolMod = require(path.join(__dirname, '..', 'tools', step.tool + '.js'));
           const fn = toolMod.execute || (toolMod.default && toolMod.default.execute);
           if (!fn) { throw new Error(step.tool + ' toolunda execute fonksiyonu bulunamadi'); }
-          const toolResult = await fn(args);
+          const toolResult = await executeThroughGateway({
+            toolName: step.tool,
+            args,
+            resolveTool: () => toolMod,
+            execute: fn,
+            normalizeSuccess: value => value,
+            normalizeError: error => ({ success: false, error }),
+          });
           stepResults.push({ step: step.step, tool: step.tool, status: 'done', args, result: toolResult });
         } else if (msg.content) {
           stepResults.push({ step: step.step, tool: step.tool, status: 'done', note: 'Tool cagrilmadi, model dogrudan yanit verdi', content: msg.content.slice(0, 500) });