natureco-cli 5.63.0 → 5.64.0

package/src/utils/secure-sync.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const crypto = require('crypto');
+
+function deriveKey(syncKey, salt) { return crypto.scryptSync(String(syncKey), salt, 32); }
+
+function encryptSyncPayload(payload, options = {}) {
+  if (!options.syncKey) throw new Error('syncKey is required');
+  if (!options.deviceId) throw new Error('deviceId is required');
+  const salt = crypto.randomBytes(16); const iv = crypto.randomBytes(12);
+  const key = deriveKey(options.syncKey, salt);
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+  const header = { version: 1, deviceId: options.deviceId, revision: options.revision || 1, clock: options.clock || { [options.deviceId]: options.revision || 1 }, createdAt: new Date().toISOString() };
+  cipher.setAAD(Buffer.from(JSON.stringify(header)));
+  const encrypted = Buffer.concat([cipher.update(JSON.stringify(payload), 'utf8'), cipher.final()]);
+  return { ...header, algorithm: 'aes-256-gcm', salt: salt.toString('base64'), iv: iv.toString('base64'), tag: cipher.getAuthTag().toString('base64'), ciphertext: encrypted.toString('base64') };
+}
+
+function decryptSyncPayload(envelope, options = {}) {
+  if (!options.syncKey) throw new Error('syncKey is required');
+  if (!envelope || envelope.version !== 1 || envelope.algorithm !== 'aes-256-gcm') throw new Error('unsupported sync envelope');
+  const header = { version: envelope.version, deviceId: envelope.deviceId, revision: envelope.revision, clock: envelope.clock, createdAt: envelope.createdAt };
+  try {
+    const key = deriveKey(options.syncKey, Buffer.from(envelope.salt, 'base64'));
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, Buffer.from(envelope.iv, 'base64'));
+    decipher.setAAD(Buffer.from(JSON.stringify(header))); decipher.setAuthTag(Buffer.from(envelope.tag, 'base64'));
+    return { header, payload: JSON.parse(Buffer.concat([decipher.update(Buffer.from(envelope.ciphertext, 'base64')), decipher.final()]).toString('utf8')) };
+  } catch { throw new Error('sync payload authentication failed'); }
+}
+
+function compareClocks(left = {}, right = {}) {
+  const devices = new Set([...Object.keys(left), ...Object.keys(right)]);
+  let leftAhead = false, rightAhead = false;
+  for (const device of devices) {
+    const l = left[device] || 0, r = right[device] || 0;
+    if (l > r) leftAhead = true; if (r > l) rightAhead = true;
+  }
+  if (leftAhead && rightAhead) return 'concurrent';
+  if (leftAhead) return 'after';
+  if (rightAhead) return 'before';
+  return 'equal';
+}
+
+function mergeSyncRecords(local = [], remote = []) {
+  const records = new Map(); const conflicts = [];
+  for (const item of [...local, ...remote]) {
+    if (!item?.id) continue;
+    const existing = records.get(item.id);
+    if (!existing) { records.set(item.id, item); continue; }
+    const relation = compareClocks(existing.clock, item.clock);
+    if (relation === 'before') records.set(item.id, item);
+    else if (relation === 'concurrent' && JSON.stringify(existing.value) !== JSON.stringify(item.value)) {
+      conflicts.push({ id: item.id, local: existing, remote: item });
+      const winner = existing.userConfirmed !== item.userConfirmed
+        ? (item.userConfirmed ? item : existing)
+        : (String(item.updatedAt || '') > String(existing.updatedAt || '') ? item : existing);
+      records.set(item.id, winner);
+    }
+  }
+  return { records: [...records.values()], conflicts };
+}
+
+module.exports = { encryptSyncPayload, decryptSyncPayload, compareClocks, mergeSyncRecords };

package/src/utils/skill-lifecycle.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { writeFileAtomicSync, writeJsonAtomicSync, readJsonSafeSync } = require('./atomic-file');
+
+function validSkill(content) {
+  return typeof content === 'string' && content.startsWith('---') && /\nname:\s*[^\n]+/.test(content) && /\ndescription:\s*[^\n]+/.test(content);
+}
+
+class SkillLifecycle {
+  constructor(root) { this.root = root; }
+  _dir(name) { return path.join(this.root, name); }
+  _meta(name) { return path.join(this._dir(name), 'lifecycle.json'); }
+
+  stage({ name, content, source = 'pattern', evidence = {} }) {
+    if (!name || !/^[a-z0-9][a-z0-9-]*$/.test(name)) return { ok: false, error: 'invalid skill name' };
+    if (!validSkill(content)) return { ok: false, error: 'invalid SKILL.md frontmatter' };
+    const id = `candidate_${crypto.randomBytes(6).toString('hex')}`;
+    return { ok: true, candidate: { id, name, content, source, evidence, status: 'candidate', createdAt: new Date().toISOString() } };
+  }
+
+  async promote(candidate, approval, validate = async () => ({ ok: true })) {
+    if (!approval?.approved || !approval.userId) return { ok: false, error: 'explicit user approval required' };
+    const validation = await validate(candidate);
+    if (!validation?.ok) return { ok: false, error: 'skill validation failed', validation };
+    const dir = this._dir(candidate.name);
+    fs.mkdirSync(path.join(dir, 'versions'), { recursive: true });
+    const meta = readJsonSafeSync(this._meta(candidate.name), { currentVersion: 0, versions: [] });
+    const version = (meta.currentVersion || 0) + 1;
+    const currentPath = path.join(dir, 'SKILL.md');
+    if (fs.existsSync(currentPath) && meta.currentVersion) {
+      writeFileAtomicSync(path.join(dir, 'versions', `${meta.currentVersion}.md`), fs.readFileSync(currentPath));
+    }
+    writeFileAtomicSync(currentPath, candidate.content);
+    meta.currentVersion = version;
+    meta.versions.push({ version, candidateId: candidate.id, source: candidate.source, evidence: candidate.evidence, approvedBy: approval.userId, approvedAt: new Date().toISOString(), validation });
+    writeJsonAtomicSync(this._meta(candidate.name), meta, { mode: 0o600 });
+    return { ok: true, name: candidate.name, version, path: currentPath, validation };
+  }
+
+  rollback(name, version, approval) {
+    if (!approval?.approved || !approval.userId) return { ok: false, error: 'explicit user approval required' };
+    const dir = this._dir(name);
+    const source = path.join(dir, 'versions', `${version}.md`);
+    if (!fs.existsSync(source)) return { ok: false, error: `version not found: ${version}` };
+    const current = path.join(dir, 'SKILL.md');
+    const meta = readJsonSafeSync(this._meta(name), { currentVersion: 0, versions: [] });
+    if (fs.existsSync(current) && meta.currentVersion) writeFileAtomicSync(path.join(dir, 'versions', `${meta.currentVersion}.md`), fs.readFileSync(current));
+    writeFileAtomicSync(current, fs.readFileSync(source));
+    meta.currentVersion = version;
+    meta.rollback = { toVersion: version, approvedBy: approval.userId, at: new Date().toISOString() };
+    writeJsonAtomicSync(this._meta(name), meta, { mode: 0o600 });
+    return { ok: true, name, version, path: current };
+  }
+}
+
+module.exports = { SkillLifecycle, validSkill };

package/src/utils/structural-patch.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { writeFileAtomicSync } = require('./atomic-file');
+
+function hashContent(content) { return crypto.createHash('sha256').update(content).digest('hex'); }
+
+class StructuralPatchEngine {
+  constructor(options = {}) {
+    this.history = new Map();
+    this.maxHistory = options.maxHistory || 50;
+  }
+
+  inspect(filePath) {
+    const target = path.resolve(filePath);
+    if (!fs.existsSync(target)) return { exists: false, path: target, hash: null, content: '' };
+    const content = fs.readFileSync(target, 'utf8');
+    return { exists: true, path: target, hash: hashContent(content), content };
+  }
+
+  preview(filePath, operations, options = {}) {
+    const state = this.inspect(filePath);
+    if (options.expectedHash && options.expectedHash !== state.hash) {
+      return { ok: false, error: 'conflict: file changed since it was read', expectedHash: options.expectedHash, actualHash: state.hash };
+    }
+    let updated = state.content;
+    const changes = [];
+    for (const [index, operation] of (operations || []).entries()) {
+      const search = operation.search;
+      const replacement = operation.replace ?? '';
+      if (typeof search !== 'string' || search.length === 0) return { ok: false, error: `operation ${index}: search is required` };
+      const occurrences = updated.split(search).length - 1;
+      if (occurrences === 0) return { ok: false, error: `operation ${index}: search text not found` };
+      if (occurrences > 1 && !operation.replaceAll) return { ok: false, error: `operation ${index}: search is ambiguous (${occurrences} matches)` };
+      updated = operation.replaceAll ? updated.split(search).join(replacement) : updated.replace(search, replacement);
+      changes.push({ index, occurrences: operation.replaceAll ? occurrences : 1, removedChars: search.length, addedChars: replacement.length });
+    }
+    return {
+      ok: true, path: state.path, beforeHash: state.hash, afterHash: hashContent(updated),
+      before: state.content, after: updated, changes,
+      risk: changes.length > 10 || Math.abs(updated.length - state.content.length) > 10000 ? 'high' : changes.length > 3 ? 'medium' : 'low',
+    };
+  }
+
+  apply(filePath, operations, options = {}) {
+    const preview = this.preview(filePath, operations, options);
+    if (!preview.ok || options.dryRun) return preview;
+    const id = `patch_${Date.now().toString(36)}_${crypto.randomBytes(3).toString('hex')}`;
+    writeFileAtomicSync(preview.path, preview.after);
+    this.history.set(id, { path: preview.path, content: preview.before, expectedHash: preview.afterHash });
+    while (this.history.size > this.maxHistory) this.history.delete(this.history.keys().next().value);
+    return { ok: true, id, path: preview.path, beforeHash: preview.beforeHash, afterHash: preview.afterHash, changes: preview.changes, risk: preview.risk };
+  }
+
+  rollback(id) {
+    const entry = this.history.get(id);
+    if (!entry) return { ok: false, error: `unknown patch: ${id}` };
+    const current = this.inspect(entry.path);
+    if (current.hash !== entry.expectedHash) return { ok: false, error: 'rollback conflict: file changed after patch', actualHash: current.hash };
+    writeFileAtomicSync(entry.path, entry.content);
+    this.history.delete(id);
+    return { ok: true, id, path: entry.path, hash: hashContent(entry.content) };
+  }
+}
+
+module.exports = { StructuralPatchEngine, hashContent };

package/src/utils/sub-agent.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { getProviderConfig } = require('./api');
+const { AgentWorkspaceManager } = require('./agent-workspace');
 
 const SUB_AGENTS_FILE = path.join(os.homedir(), '.natureco', 'sub-agents.json');
 
@@ -64,12 +65,15 @@ async function spawnSubAgent(type, task, options = {}) {
   saveAgents(agents);
 
   try {
+    const workspaceManager = options.workspaceManager || new AgentWorkspaceManager();
+    const useWorkspace = options.isolatedWorktree !== false && ['general', 'debugger'].includes(type);
+    const executeAgent = async (workspace = null) => {
     const providerConfig = getProviderConfig();
     if (!providerConfig) {
       throw new Error('Provider not configured. Run: natureco configure');
     }
 
-    const systemPrompt = options.systemPrompt || SYSTEM_PROMPTS[type];
+    const systemPrompt = (options.systemPrompt || SYSTEM_PROMPTS[type]) + (workspace ? `\n\nIsolated workspace: ${workspace.cwd}\nOnly operate inside this workspace.` : '');
 
     const baseUrl = providerConfig.url.replace(/\/+$/, '');
     const endpoint = `${baseUrl}/chat/completions`;
@@ -109,7 +113,14 @@ async function spawnSubAgent(type, task, options = {}) {
     const usage = data.usage || {};
     const duration = new Date(entry.completedAt) - new Date(entry.startedAt);
 
-    return { result: content, usage, duration };
+    return { result: content, usage, duration, workspace: workspace?.cwd || null };
+    };
+    if (useWorkspace) {
+      const isolated = await workspaceManager.run(entry.id, executeAgent, { merge: options.mergeWorktree === true });
+      if (!isolated.ok) throw new Error(isolated.error);
+      return isolated.result;
+    }
+    return await executeAgent();
   } catch (err) {
     entry.status = 'failed';
     entry.result = err.message;

package/src/utils/test-failure-analyzer.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const crypto = require('crypto');
+
+function fingerprint(text) {
+  return crypto.createHash('sha256').update(String(text || '').replace(/\d+ms|\d+\.\d+s|\d+/g, '#')).digest('hex').slice(0, 16);
+}
+
+function analyzeTestFailure(output, exitCode = 1) {
+  const text = String(output || '');
+  const findings = [];
+  const patterns = [
+    { type: 'assertion', re: /(?:AssertionError|expected .* (?:to|but)|FAIL\s+)([^\n]*)/gi },
+    { type: 'syntax', re: /(?:SyntaxError|ParseError)[:\s]+([^\n]*)/gi },
+    { type: 'type', re: /(?:TypeError|TS\d{4}:)[:\s]*([^\n]*)/gi },
+    { type: 'module', re: /(?:Cannot find module|ModuleNotFoundError)[:\s]*([^\n]*)/gi },
+    { type: 'timeout', re: /(?:timed out|timeout of \d+ms exceeded|Test timeout)/gi },
+  ];
+  for (const pattern of patterns) {
+    pattern.re.lastIndex = 0;
+    let match;
+    while ((match = pattern.re.exec(text)) && findings.length < 50) {
+      findings.push({ type: pattern.type, message: (match[1] || match[0]).trim().slice(0, 500) });
+    }
+  }
+  const locations = [...text.matchAll(/(?:\(|\s)([^\s():]+\.(?:js|ts|tsx|jsx|py|go|rs|java)):(\d+)(?::(\d+))?/g)]
+    .slice(0, 50).map(match => ({ file: match[1], line: Number(match[2]), column: match[3] ? Number(match[3]) : null }));
+  const summaryMatch = text.match(/(\d+)\s+(?:failed|failing|failures?)/i);
+  return {
+    ok: exitCode === 0,
+    exitCode,
+    framework: /vitest/i.test(text) ? 'vitest' : /jest/i.test(text) ? 'jest' : /pytest|FAILED .*\.py/i.test(text) ? 'pytest' : /TS\d{4}/.test(text) ? 'typescript' : 'unknown',
+    failedCount: summaryMatch ? Number(summaryMatch[1]) : (exitCode === 0 ? 0 : Math.max(1, findings.length)),
+    findings, locations, fingerprint: fingerprint(text), rawTail: text.slice(-6000),
+  };
+}
+
+class AutoFixLoop {
+  constructor(options = {}) { this.maxAttempts = options.maxAttempts || 3; }
+
+  async run({ runTests, proposeFix, onAttempt }) {
+    const attempts = [];
+    let previousFingerprint = null;
+    for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+      const startedAt = Date.now();
+      const testResult = await runTests({ attempt });
+      const analysis = analyzeTestFailure(testResult.output, testResult.exitCode);
+      const record = { attempt, analysis, durationMs: Date.now() - startedAt };
+      attempts.push(record);
+      if (onAttempt) await onAttempt(record);
+      if (analysis.ok) return { ok: true, attempts };
+      if (analysis.fingerprint === previousFingerprint) {
+        return { ok: false, stopped: 'no-progress', attempts, analysis };
+      }
+      previousFingerprint = analysis.fingerprint;
+      const fix = await proposeFix({ attempt, analysis, attempts });
+      record.fix = fix || null;
+      if (!fix || fix.applied === false) return { ok: false, stopped: 'no-fix', attempts, analysis };
+    }
+    return { ok: false, stopped: 'max-attempts', attempts, analysis: attempts.at(-1)?.analysis };
+  }
+}
+
+module.exports = { analyzeTestFailure, AutoFixLoop, fingerprint };

package/src/utils/tool-execution-gateway.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const { assessToolPath } = require('./tool-path-policy');
+const { validateJsonSchema } = require('./json-schema');
+const { standardToolResult } = require('./tool-result');
+
+// Transport-agnostic pipeline: resolve -> availability -> policy -> execute -> post-process.
+async function executeThroughGateway(options) {
+  const {
+    toolName, args = {}, resolveTool, checkAvailability, policyChecks = [],
+    execute, postProcess, allowSensitivePaths = false, standardResult = false,
+    normalizeSuccess = result => ({ result }),
+    normalizeError = error => ({ error }),
+  } = options || {};
+
+  if (!toolName || typeof resolveTool !== 'function') {
+    return normalizeError('Geçersiz araç çalıştırma isteği');
+  }
+
+  let tool;
+  try { tool = await resolveTool(toolName); }
+  catch (error) { return normalizeError(error?.message || String(error)); }
+
+  if (!tool) return normalizeError(`Tool bulunamadı: ${toolName}`);
+  const executor = execute || tool.execute;
+  if (typeof executor !== 'function') return normalizeError(`Tool execute fonksiyonu yok: ${toolName}`);
+
+  try {
+    const schema = tool.inputSchema || tool.parameters || tool.schema?.parameters;
+    const validation = validateJsonSchema(schema, args);
+    if (!validation.valid) return normalizeError(`Geçersiz araç argümanları: ${validation.errors.join('; ')}`);
+    if (!allowSensitivePaths) {
+      const pathDecision = assessToolPath(toolName, args);
+      if (!pathDecision.allowed) return normalizeError(pathDecision.reason);
+    }
+    if (checkAvailability) {
+      const decision = await checkAvailability({ toolName, args, tool });
+      if (decision === false) return normalizeError(`${toolName} şu anda kullanılamıyor`);
+      if (decision?.allowed === false) return normalizeError(decision.reason || `${toolName} şu anda kullanılamıyor`);
+    }
+    for (const check of policyChecks) {
+      if (typeof check !== 'function') continue;
+      const decision = await check({ toolName, args, tool });
+      if (decision === false) return normalizeError('Araç çalıştırma politikası engelledi');
+      if (decision?.allowed === false) return normalizeError(decision.reason || 'Araç çalıştırma politikası engelledi');
+    }
+    let result = await executor.call(tool, args);
+    if (postProcess) result = await postProcess({ toolName, args, tool, result });
+    if (standardResult) return standardToolResult(result, { tool: toolName });
+    return normalizeSuccess(result);
+  } catch (error) {
+    return normalizeError(error?.message || String(error));
+  }
+}
+
+module.exports = { executeThroughGateway };

package/src/utils/tool-manifest.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+let cache = null;
+
+function loadToolManifest({ toolsDir = path.join(__dirname, '..', 'tools'), refresh = false } = {}) {
+  if (cache && !refresh) return cache;
+  const entries = new Map();
+  if (!fs.existsSync(toolsDir)) return entries;
+  for (const file of fs.readdirSync(toolsDir).filter(name => name.endsWith('.js')).sort()) {
+    try {
+      const mod = require(path.join(toolsDir, file));
+      const name = mod.name || path.basename(file, '.js');
+      const execute = mod.execute || mod.default?.execute;
+      if (!name || typeof execute !== 'function') continue;
+      entries.set(name, {
+        name, description: mod.description || `${name} tool`,
+        inputSchema: mod.inputSchema || mod.parameters || { type: 'object', properties: {} },
+        execute, module: mod, source: file,
+      });
+    } catch { /* unavailable optional tool */ }
+  }
+  cache = entries;
+  return entries;
+}
+
+function clearToolManifestCache() { cache = null; }
+
+module.exports = { loadToolManifest, clearToolManifestCache };

package/src/utils/tool-path-policy.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+
+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 = [
+  ...SENSITIVE_READ,
+  /(^|[\\/])authorized_keys$/i, /System32[\\/]drivers[\\/]etc/i,
+  /\.aws[\\/]credentials/i,
+  /^[/\\](etc|usr|bin|sbin|boot|sys)[\\/]/i,
+  /(^|[\\/])etc[\\/](passwd|shadow|sudoers|hosts|crontab|ssh)/i,
+];
+
+function expandPath(value) {
+  if (typeof value !== 'string' || !value.trim()) return value;
+  const trimmed = value.trim();
+  if (trimmed === '~') return os.homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return path.join(os.homedir(), trimmed.slice(2));
+  }
+  return path.resolve(trimmed);
+}
+
+function assessToolPath(toolName, args = {}) {
+  const rawPath = args.path || args.filePath || args.file_path;
+  if (!rawPath) return { allowed: true };
+  const targetPath = expandPath(rawPath);
+  const write = toolName === 'write_file' || toolName === 'edit_file' || toolName === 'structural_patch';
+  const read = toolName === 'read_file';
+  if (!write && !read) return { allowed: true, path: targetPath };
+  const patterns = write ? SENSITIVE_WRITE : SENSITIVE_READ;
+  if (patterns.some(pattern => pattern.test(targetPath))) {
+    return {
+      allowed: false,
+      path: targetPath,
+      reason: `Hassas dosya yolu güvenlik politikasıyla engellendi: ${targetPath}`,
+    };
+  }
+  return { allowed: true, path: targetPath };
+}
+
+module.exports = { assessToolPath, expandPath, SENSITIVE_READ, SENSITIVE_WRITE };

package/src/utils/tool-result.js

@@ -0,0 +1,17 @@
+'use strict';
+
+function standardToolResult(value, metrics = {}) {
+  if (value && typeof value === 'object' && typeof value.ok === 'boolean' && 'data' in value) return value;
+  const failed = value && typeof value === 'object' && (value.success === false || value.error);
+  const error = failed ? String(value.error || 'Tool execution failed') : null;
+  return {
+    ok: !failed,
+    data: failed ? null : value,
+    error,
+    warnings: Array.isArray(value?.warnings) ? value.warnings : [],
+    artifacts: Array.isArray(value?.artifacts) ? value.artifacts : [],
+    metrics: { ...metrics, ...(value?.metrics || {}) },
+  };
+}
+
+module.exports = { standardToolResult };

package/src/utils/tool-runner.js

@@ -1,7 +1,11 @@
 const fs = require('fs');
 const path = require('path');
-const chalk = require('chalk');
-const inquirer = require('./inquirer-wrapper');
+const chalk = require('chalk');
+const inquirer = require('./inquirer-wrapper');
+const { executeThroughGateway } = require('./tool-execution-gateway');
+const { checkPermission } = require('./permissions');
+const { checkPreHooks, runPostHooks } = require('./tool-hooks');
+const { loadToolManifest } = require('./tool-manifest');
 
 // ── Spinner ───────────────────────────────────────────────────────────────────
 const SPINNER_FRAMES = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
@@ -12,8 +16,8 @@ function startSpinner(label) {
     process.stdout.write(`\r${chalk.cyan(SPINNER_FRAMES[i++ % SPINNER_FRAMES.length])} ${chalk.gray(label)}`);
   }, 80);
   return timer;
-}
-
+}
+
 function stopSpinner(timer, label, success = true) {
   clearInterval(timer);
   if (success) {
@@ -55,23 +59,15 @@ function resetSessionStats() {
 }
 
 // ── Load tools ────────────────────────────────────────────────────────────────
-function loadTools() {
-  const toolsDir = path.join(__dirname, '..', 'tools');
-  const tools = {};
-
-  if (!fs.existsSync(toolsDir)) return tools;
-
-  const files = fs.readdirSync(toolsDir).filter(f => f.endsWith('.js'));
-  for (const file of files) {
-    try {
-      const tool = require(path.join(toolsDir, file));
-      if (tool.name && tool.execute) tools[tool.name] = tool;
-    } catch (err) {
-      console.error(chalk.red(`Failed to load tool ${file}:`, err.message));
-    }
-  }
-  return tools;
-}
+function loadTools() {
+  return Object.fromEntries([...loadToolManifest()].map(([name, entry]) => [name, {
+    ...entry.module,
+    name: entry.name,
+    description: entry.description,
+    inputSchema: entry.inputSchema,
+    execute: entry.execute,
+  }]));
+}
 
 function getToolDefinitions() {
   const tools = loadTools();
@@ -90,11 +86,12 @@ function getToolDefinitions() {
 // v5.51.1 GÜVENLİK: edit_file eklendi — write_file diff+onay isterken, aynı riski
 // taşıyan hedefli değişiklik (edit_file) onaysız geçiyordu (SELF.md kendini-onarma
 // + Tek Beyin kanal erişimiyle birleşince kritik).
-function needsConfirmation(toolName, params) {
+function needsConfirmation(toolName, params) {
   const p = params || {};
   return (
-    toolName === 'write_file' ||
-    toolName === 'edit_file' ||
+    toolName === 'write_file' ||
+    toolName === 'edit_file' ||
+    toolName === 'structural_patch' ||
     ((toolName === 'bash' || toolName === 'shell_command') && /\b(rm|mv|cp|chmod|chown|dd|mkfs|truncate)\b/.test(p.command || ''))
   );
 }
@@ -103,18 +100,33 @@ function needsConfirmation(toolName, params) {
 async function executeTool(toolName, params, opts = {}) {
   const safeParams = params ?? {};
   const tools = loadTools();
-  const tool = tools[toolName];
-  const agentMode = opts.agentMode || false;
-
-  if (!tool) {
-    return { success: false, error: `Tool '${toolName}' not found` };
-  }
+  const tool = tools[toolName];
+  const agentMode = opts.agentMode || false;
+  if (!tool) {
+    return { success: false, error: `Tool '${toolName}' not found` };
+  }
+
+  // Configured permission rules and pre-hooks are mandatory in every origin.
+  // Interactive callers may approve `ask`; API/headless/channel callers must
+  // fail closed because they cannot prove that a human approved the action.
+  const permission = checkPermission(toolName, safeParams);
+  const hook = checkPreHooks(toolName, safeParams);
+  const policy = evaluatePolicyDecision(permission, hook, opts);
+  const policyAsk = policy.needsApproval ? { reason: policy.reason } : null;
+  if (!policy.allowed) {
+    return {
+      success: false,
+      error: policy.needsApproval
+        ? `Etkileşimsiz çağrıda kullanıcı onayı gerekiyor: ${policy.reason || toolName}`
+        : policy.reason || 'Araç güvenlik politikasıyla engellendi.',
+    };
+  }
 
   const label = `${toolName}${safeParams.path ? ' — ' + safeParams.path : safeParams.command ? ' — ' + safeParams.command : ''}`;
 
   // ── Onay mekanizması (dosya değiştiren araçlar ve tehlikeli bash) ──────────
-  if (agentMode) {
-    if (needsConfirmation(toolName, safeParams)) {
+  if (agentMode) {
+    if (policyAsk || needsConfirmation(toolName, safeParams)) {
       if (toolName === 'write_file') {
         // Diff göster
         let oldContent = '';
@@ -136,8 +148,9 @@ async function executeTool(toolName, params, opts = {}) {
         console.log(chalk.yellow(`\n  🖥️  Komut: ${chalk.white(safeParams.command)}\n`));
       }
 
-      const confirmMsg =
-        toolName === 'write_file' ? `✏️  ${safeParams.path} dosyası değiştirilecek` :
+      const confirmMsg =
+        policyAsk ? `🛡️  ${policyAsk.reason || toolName + ' için izin gerekli'}` :
+        toolName === 'write_file' ? `✏️  ${safeParams.path} dosyası değiştirilecek` :
         toolName === 'edit_file' ? `✏️  ${safeParams.path} dosyasında değişiklik yapılacak` :
         '⚠️  Bu komut çalıştırılacak';
       const { confirm } = await inquirer.prompt([{
@@ -155,23 +168,37 @@ async function executeTool(toolName, params, opts = {}) {
   }
 
   // ── Spinner ile çalıştır ──────────────────────────────────────────────────
-  const spinner = startSpinner(label);
-  try {
-    const result = await tool.execute(safeParams);
-    stopSpinner(spinner, label, result.success !== false);
-
-    // İstatistik güncelle
-    if (result.success !== false) {
-      if (toolName === 'write_file' || toolName === 'edit_file') filesChanged++;
-      if (toolName === 'bash') commandsRun++;
-    }
-
-    return result;
-  } catch (error) {
-    stopSpinner(spinner, label, false);
-    return { success: false, error: error.message };
-  }
-}
+  const spinner = startSpinner(label);
+  const result = await executeThroughGateway({
+    toolName,
+    args: safeParams,
+    resolveTool: () => tool,
+    postProcess: ({ result: value }) => runPostHooks(toolName, safeParams, value),
+    normalizeSuccess: value => value,
+    normalizeError: error => ({ success: false, error }),
+    allowSensitivePaths: !!opts.allowSensitivePaths,
+  });
+  stopSpinner(spinner, label, result.success !== false);
+
+  // İstatistik güncelle
+  if (result.success !== false) {
+    if (toolName === 'write_file' || toolName === 'edit_file' || toolName === 'structural_patch') filesChanged++;
+    if (toolName === 'bash' || toolName === 'shell_command') commandsRun++;
+  }
+
+  return result;
+}
+
+function evaluatePolicyDecision(permission, hook, opts = {}) {
+  const decisions = [permission, hook].filter(Boolean);
+  const denied = decisions.find(decision => decision.action === 'deny');
+  if (denied) return { allowed: false, needsApproval: false, reason: denied.reason };
+  const asked = decisions.find(decision => decision.action === 'ask');
+  if (!asked) return { allowed: true, needsApproval: false };
+  if (opts.agentMode) return { allowed: true, needsApproval: true, reason: asked.reason };
+  if (opts.approvalMode === 'preapproved') return { allowed: true, needsApproval: false };
+  return { allowed: false, needsApproval: true, reason: asked.reason };
+}
 
 // ── Execute multiple tool calls (parallel for independent, sequential for others) ──
 const PARALLEL_SAFE_TOOLS = new Set(['read_file', 'file_search', 'grep_search', 'web_search', 'web_readability', 'duckduckgo_search', 'exa_search', 'searxng_search', 'firecrawl', 'memory_search', 'memory']);
@@ -210,5 +237,6 @@ module.exports = {
   executeToolCalls,
   getSessionStats,
   resetSessionStats,
-  needsConfirmation,
-};
+  needsConfirmation,
+  evaluatePolicyDecision,
+};