svamp-cli 0.2.45 → 0.2.46

package/dist/{run-D59qJKn_.mjs → run-wfhhtkl1.mjs}

@@ -1,16 +1,16 @@
-import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import os from 'os';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import os$1 from 'os';
 import fs, { mkdir as mkdir$1, readdir as readdir$1, readFile, writeFile as writeFile$1, rename, unlink } from 'fs/promises';
-import { readFileSync as readFileSync$1, mkdirSync, writeFileSync, renameSync, existsSync as existsSync$1, copyFileSync, unlinkSync, watch, rmdirSync } from 'fs';
+import { readFileSync as readFileSync$1, mkdirSync, writeFileSync, renameSync, existsSync as existsSync$1, copyFileSync, unlinkSync as unlinkSync$1, watch, rmdirSync } from 'fs';
 import path__default, { join, dirname, resolve, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { spawn as spawn$1, execSync as execSync$1 } from 'child_process';
 import { randomUUID as randomUUID$1 } from 'crypto';
-import { existsSync, readFileSync, writeFileSync as writeFileSync$1, mkdirSync as mkdirSync$1, appendFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync as writeFileSync$1, mkdirSync as mkdirSync$1, appendFileSync, unlinkSync } from 'node:fs';
 import { randomUUID, createHash } from 'node:crypto';
 import { join as join$1 } from 'node:path';
 import { spawn, execSync, execFile, execFileSync } from 'node:child_process';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
-import { homedir, platform } from 'node:os';
+import os, { homedir, platform } from 'node:os';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
@@ -1107,7 +1107,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const tunnels = handlers.tunnels;
         if (!tunnels) throw new Error("Tunnel management not available");
         if (tunnels.has(params.name)) throw new Error(`Tunnel '${params.name}' already running`);
-        const { FrpcTunnel } = await import('./frpc-DzRFx60H.mjs');
+        const { FrpcTunnel } = await import('./frpc-j60b46eU.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -5092,6 +5092,8 @@ const DEFAULT_PROBE_FAILURE_THRESHOLD = 3;
 const MAX_RESTART_DELAY_S = 300;
 const BACKOFF_RESET_WINDOW_MS = 6e4;
 const MAX_LOG_LINES = 300;
+const CRASH_LOOP_FAILURE_THRESHOLD = 10;
+const CRASH_LOOP_WINDOW_MS = 3e5;
 class ProcessSupervisor {
   entries = /* @__PURE__ */ new Map();
   persistDir;
@@ -5139,11 +5141,13 @@ class ProcessSupervisor {
   /** Start a stopped/failed process by id or name. */
   async start(idOrName) {
     const entry = this.require(idOrName);
+    if (entry.deleted) throw new Error(`Process '${idOrName}' has been removed`);
     if (entry.child) {
       if (entry.stopping) throw new Error(`Process '${entry.spec.name}' is being stopped, try again shortly`);
       throw new Error(`Process '${entry.spec.name}' is already running`);
     }
     entry.stopping = false;
+    this.resetFailureTracking(entry);
     await this.startEntry(entry, false);
   }
   /** Stop a running process. Does NOT remove it from supervision. */
@@ -5162,6 +5166,7 @@ class ProcessSupervisor {
   /** Restart a process (stop if running, then start again). */
   async restart(idOrName) {
     const entry = this.require(idOrName);
+    if (entry.deleted) throw new Error(`Process '${idOrName}' has been removed`);
     if (entry.restarting) return;
     entry.restarting = true;
     try {
@@ -5171,7 +5176,9 @@ class ProcessSupervisor {
         await this.killChild(entry.child);
         entry.child = void 0;
       }
+      if (entry.deleted) return;
       entry.stopping = false;
+      this.resetFailureTracking(entry);
       entry.state.restartCount++;
       await this.startEntry(entry, false);
     } finally {
@@ -5182,7 +5189,16 @@ class ProcessSupervisor {
   async remove(idOrName) {
     const entry = this.require(idOrName);
     const id = entry.spec.id;
-    await this.stop(entry.spec.name);
+    entry.deleted = true;
+    entry.stopping = true;
+    this.clearTimers(entry);
+    if (entry.child) {
+      await this.killChild(entry.child);
+      entry.child = void 0;
+    }
+    entry.state.status = "stopped";
+    entry.state.stoppedAt = Date.now();
+    entry.state.pid = void 0;
     this.entries.delete(id);
     await this.deleteSpec(id);
   }
@@ -5232,7 +5248,9 @@ class ProcessSupervisor {
       await this.killChild(existing.child);
       existing.child = void 0;
     }
+    if (existing.deleted) return { action: "updated", info: this.toInfo(existing) };
     existing.stopping = false;
+    this.resetFailureTracking(existing);
     existing.state.status = "starting";
     this.spawnProcess(existing);
     return { action: "updated", info: this.toInfo(existing) };
@@ -5243,6 +5261,7 @@ class ProcessSupervisor {
    */
   async update(idOrName, partialSpec) {
     const entry = this.require(idOrName);
+    if (entry.deleted) throw new Error(`Process '${idOrName}' has been removed`);
     const updatedSpec = { ...entry.spec, ...partialSpec };
     entry.spec = updatedSpec;
     await this.persistSpec(updatedSpec);
@@ -5252,7 +5271,9 @@ class ProcessSupervisor {
       await this.killChild(entry.child);
       entry.child = void 0;
     }
+    if (entry.deleted) return this.toInfo(entry);
     entry.stopping = false;
+    this.resetFailureTracking(entry);
     entry.state.status = "starting";
     this.spawnProcess(entry);
     return this.toInfo(entry);
@@ -5328,7 +5349,8 @@ class ProcessSupervisor {
         id: spec.id,
         status: "pending",
         restartCount: 0,
-        consecutiveProbeFailures: 0
+        consecutiveProbeFailures: 0,
+        consecutiveFailures: 0
       },
       logBuffer: [],
       stopping: false
@@ -5348,6 +5370,7 @@ class ProcessSupervisor {
   // ── Process spawning ──────────────────────────────────────────────────────
   async startEntry(entry, onRestore) {
     const { spec } = entry;
+    if (entry.deleted) return;
     if (spec.ttl !== void 0 && spec.ttl > 0 && onRestore) {
       const elapsedS = (Date.now() - spec.createdAt) / 1e3;
       if (elapsedS >= spec.ttl) {
@@ -5366,6 +5389,7 @@ class ProcessSupervisor {
   }
   spawnProcess(entry) {
     const { spec, state } = entry;
+    if (entry.deleted) return;
     try {
       const env = { ...process.env, ...spec.env ?? {} };
       const child = spawn$1(spec.command, spec.args, {
@@ -5408,6 +5432,7 @@ class ProcessSupervisor {
     state.pid = void 0;
     state.stoppedAt = Date.now();
     this.clearTimers(entry);
+    if (entry.deleted) return;
     if (entry.stopping) {
       state.status = "stopped";
       console.log(`[SUPERVISOR] Process '${spec.name}' stopped (code=${code})`);
@@ -5417,31 +5442,65 @@ class ProcessSupervisor {
     state.status = crashed ? "failed" : "stopped";
     console.log(`[SUPERVISOR] Process '${spec.name}' exited (code=${code}, signal=${signal})`);
     if (!spec.keepAlive) return;
+    const uptime = state.startedAt ? Date.now() - state.startedAt : 0;
+    const now = Date.now();
+    if (uptime > BACKOFF_RESET_WINDOW_MS) {
+      state.restartCount = 0;
+      state.consecutiveFailures = 0;
+      entry.failureWindowStart = void 0;
+    } else {
+      if (!entry.failureWindowStart || now - entry.failureWindowStart > CRASH_LOOP_WINDOW_MS) {
+        entry.failureWindowStart = now;
+        state.consecutiveFailures = 1;
+      } else {
+        state.consecutiveFailures++;
+      }
+    }
+    if (state.consecutiveFailures >= CRASH_LOOP_FAILURE_THRESHOLD) {
+      const windowS = Math.round((now - (entry.failureWindowStart ?? now)) / 1e3);
+      state.status = "crash-loop-backoff";
+      state.crashLoopBackOff = {
+        enteredAt: now,
+        failureCount: state.consecutiveFailures,
+        windowStart: entry.failureWindowStart ?? now
+      };
+      console.error(
+        `[SUPERVISOR] '${spec.name}' entering CrashLoopBackOff: ${state.consecutiveFailures} failures in ${windowS}s. Restarts halted \u2014 run 'svamp process restart ${spec.name}' to retry.`
+      );
+      return;
+    }
     if (spec.maxRestarts > 0 && state.restartCount >= spec.maxRestarts) {
       console.warn(`[SUPERVISOR] Process '${spec.name}' reached max restarts (${spec.maxRestarts}), not restarting`);
       state.status = "failed";
       return;
     }
-    const uptime = state.startedAt ? Date.now() - state.startedAt : 0;
     const baseDelay = spec.restartDelay * 1e3;
     let delayMs;
     if (uptime > BACKOFF_RESET_WINDOW_MS) {
-      state.restartCount = 0;
       delayMs = baseDelay;
     } else {
-      const backoffExponent = Math.min(state.restartCount, 10);
+      const backoffExponent = Math.min(state.consecutiveFailures - 1, 10);
       delayMs = Math.min(baseDelay * Math.pow(2, backoffExponent), MAX_RESTART_DELAY_S * 1e3);
       const jitter = (Math.random() * 0.2 - 0.1) * delayMs;
       delayMs = Math.max(baseDelay, Math.round(delayMs + jitter));
     }
-    console.log(`[SUPERVISOR] Scheduling restart of '${spec.name}' in ${delayMs}ms (restart #${state.restartCount + 1}, uptime=${Math.round(uptime / 1e3)}s)`);
+    console.log(
+      `[SUPERVISOR] Scheduling restart of '${spec.name}' in ${delayMs}ms (failure ${state.consecutiveFailures}/${CRASH_LOOP_FAILURE_THRESHOLD}, restart #${state.restartCount + 1}, uptime=${Math.round(uptime / 1e3)}s)`
+    );
     entry.restartTimer = setTimeout(() => {
-      if (entry.stopping) return;
+      if (entry.deleted || entry.stopping) return;
       state.restartCount++;
       state.status = "starting";
       this.spawnProcess(entry);
     }, delayMs);
   }
+  /** Reset all CrashLoopBackOff accounting. Called on user-initiated start/restart/spec-change. */
+  resetFailureTracking(entry) {
+    entry.state.consecutiveFailures = 0;
+    entry.state.consecutiveProbeFailures = 0;
+    entry.state.crashLoopBackOff = void 0;
+    entry.failureWindowStart = void 0;
+  }
   // ── Health probes ─────────────────────────────────────────────────────────
   setupProbe(entry) {
     const intervalMs = (entry.spec.probe.interval ?? DEFAULT_PROBE_INTERVAL_S) * 1e3;
@@ -5451,6 +5510,7 @@ class ProcessSupervisor {
     }, intervalMs);
   }
   async runHealthCheck(entry) {
+    if (entry.deleted || entry.stopping) return;
     if (!entry.child || entry.state.status !== "running") return;
     const probe = entry.spec.probe;
     const urlPath = probe.path ?? "/";
@@ -5491,15 +5551,17 @@ class ProcessSupervisor {
     }
   }
   async triggerProbeRestart(entry) {
-    if (entry.restarting) return;
+    if (entry.deleted) return;
     if (entry.stopping) return;
-    console.warn(`[SUPERVISOR] Restarting '${entry.spec.name}' due to probe failures`);
+    if (entry.restarting) return;
+    if (entry.state.status === "crash-loop-backoff") return;
+    console.warn(`[SUPERVISOR] Probe failed for '${entry.spec.name}' \u2014 killing to trigger restart`);
     entry.state.consecutiveProbeFailures = 0;
-    this.clearTimers(entry);
-    try {
-      await this.restart(entry.spec.id);
-    } catch (err) {
-      console.error(`[SUPERVISOR] Probe-triggered restart failed for '${entry.spec.name}': ${err.message}`);
+    if (entry.child) {
+      try {
+        entry.child.kill("SIGTERM");
+      } catch {
+      }
     }
   }
   // ── TTL ───────────────────────────────────────────────────────────────────
@@ -5514,9 +5576,11 @@ class ProcessSupervisor {
     entry.ttlTimer = setTimeout(() => this.expireProcess(entry), remainingS * 1e3);
   }
   expireProcess(entry) {
+    if (entry.deleted) return;
     console.log(`[SUPERVISOR] Process '${entry.spec.name}' TTL expired`);
     entry.state.status = "expired";
     entry.stopping = true;
+    entry.deleted = true;
     this.clearTimers(entry);
     const cleanup = async () => {
       if (entry.child) await this.killChild(entry.child);
@@ -5677,9 +5741,201 @@ You may be running in parallel with other agents \u2014 possibly sharing the sam
 `;
 }
 
+const SVAMP_HOME$1 = process.env.SVAMP_HOME || join$1(os.homedir(), ".svamp");
+function generateHookSettings(portOrOptions = {}) {
+  const opts = typeof portOrOptions === "number" ? { sessionStartPort: portOrOptions } : portOrOptions;
+  const hooksDir = join$1(SVAMP_HOME$1, "tmp", "hooks");
+  mkdirSync$1(hooksDir, { recursive: true });
+  const id = opts.id || String(process.pid);
+  const validatorPath = join$1(hooksDir, `image-validator-${id}.cjs`);
+  writeFileSync$1(validatorPath, IMAGE_VALIDATOR_SCRIPT, { mode: 493 });
+  const cleanupPaths = [validatorPath];
+  const hooks = {
+    PreToolUse: [
+      {
+        matcher: "Read",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${validatorPath}"`,
+            timeout: 5
+          }
+        ]
+      }
+    ]
+  };
+  if (typeof opts.sessionStartPort === "number" && opts.sessionStartPort > 0) {
+    const forwarderPath = join$1(hooksDir, `forwarder-${id}.cjs`);
+    const forwarderCode = `#!/usr/bin/env node
+const http = require('http');
+const port = parseInt(process.argv[2], 10);
+if (!port || isNaN(port)) process.exit(1);
+const chunks = [];
+process.stdin.on('data', c => chunks.push(c));
+process.stdin.on('end', () => {
+    const body = Buffer.concat(chunks);
+    const req = http.request({
+        host: '127.0.0.1', port, method: 'POST',
+        path: '/hook/session-start',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': body.length }
+    }, res => res.resume());
+    req.on('error', () => {});
+    req.end(body);
+});
+process.stdin.resume();
+`;
+    writeFileSync$1(forwarderPath, forwarderCode, { mode: 493 });
+    cleanupPaths.push(forwarderPath);
+    hooks.SessionStart = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${forwarderPath}" ${opts.sessionStartPort}`
+          }
+        ]
+      }
+    ];
+  }
+  const settingsPath = join$1(hooksDir, `session-hook-${id}.json`);
+  writeFileSync$1(settingsPath, JSON.stringify({ hooks }, null, 2));
+  cleanupPaths.push(settingsPath);
+  const cleanup = () => {
+    for (const p of cleanupPaths) {
+      try {
+        if (existsSync(p)) unlinkSync(p);
+      } catch {
+      }
+    }
+  };
+  return { settingsPath, validatorPath, hooksDir, cleanup };
+}
+const IMAGE_VALIDATOR_SCRIPT = `#!/usr/bin/env node
+'use strict';
+const fs = require('node:fs');
+
+const MAX_SIZE = 5 * 1024 * 1024;
+const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp']);
+
+function readStdin() {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', (c) => { data += c; });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', () => resolve(''));
+    });
+}
+
+function deny(reason) {
+    process.stderr.write(reason);
+    process.exit(2);
+}
+
+function detectFormat(head) {
+    if (head.length >= 8
+        && head[0] === 0x89 && head[1] === 0x50 && head[2] === 0x4E && head[3] === 0x47
+        && head[4] === 0x0D && head[5] === 0x0A && head[6] === 0x1A && head[7] === 0x0A) return 'png';
+    if (head.length >= 3
+        && head[0] === 0xFF && head[1] === 0xD8 && head[2] === 0xFF) return 'jpeg';
+    if (head.length >= 4
+        && head[0] === 0x47 && head[1] === 0x49 && head[2] === 0x46 && head[3] === 0x38) return 'gif';
+    if (head.length >= 12
+        && head[0] === 0x52 && head[1] === 0x49 && head[2] === 0x46 && head[3] === 0x46
+        && head[8] === 0x57 && head[9] === 0x45 && head[10] === 0x42 && head[11] === 0x50) return 'webp';
+    return null;
+}
+
+function checkTruncation(format, tail, fileSize, head) {
+    if (format === 'png') {
+        const iend = Buffer.from([0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82]);
+        if (!tail.subarray(tail.length - 12).equals(iend)) {
+            return 'PNG file is truncated or corrupt (missing IEND chunk).';
+        }
+    } else if (format === 'jpeg') {
+        const last2 = tail.subarray(tail.length - 2);
+        if (last2[0] !== 0xFF || last2[1] !== 0xD9) {
+            return 'JPEG file is truncated (missing FF D9 EOI marker).';
+        }
+    } else if (format === 'gif') {
+        if (tail[tail.length - 1] !== 0x3B) {
+            return 'GIF file is truncated (missing 0x3B trailer).';
+        }
+    } else if (format === 'webp') {
+        const riffSize = head.readUInt32LE(4);
+        if (riffSize !== fileSize - 8) {
+            return 'WebP file is corrupt (RIFF size ' + riffSize + ' != fileSize-8 ' + (fileSize - 8) + ').';
+        }
+    }
+    return null;
+}
+
+(async () => {
+    const raw = await readStdin();
+    let input;
+    try { input = JSON.parse(raw); } catch { return; }
+    if (!input || input.tool_name !== 'Read') return;
+    const filePath = input.tool_input && input.tool_input.file_path;
+    if (typeof filePath !== 'string' || !filePath) return;
+
+    const dot = filePath.lastIndexOf('.');
+    if (dot < 0) return;
+    const ext = filePath.slice(dot).toLowerCase();
+    if (!IMAGE_EXTS.has(ext)) return;
+
+    let stat;
+    try { stat = fs.statSync(filePath); } catch { return; } // missing \u2192 let Read tool report
+    if (!stat.isFile()) return;
+
+    if (stat.size === 0) {
+        deny('Image file is empty (0 bytes): ' + filePath + '. The Anthropic API will reject this image. Skip reading it.');
+    }
+    if (stat.size > MAX_SIZE) {
+        deny('Image file is too large (' + (stat.size / 1024 / 1024).toFixed(1) + ' MB > 5 MB): ' + filePath + '. The Anthropic API rejects images larger than 5 MB. Skip reading it.');
+    }
+    if (stat.size < 12) {
+        deny('Image file is too small to be a valid image (' + stat.size + ' bytes): ' + filePath + '. Skip reading it.');
+    }
+
+    let head;
+    let tail;
+    try {
+        const fd = fs.openSync(filePath, 'r');
+        try {
+            head = Buffer.alloc(32);
+            const headLen = fs.readSync(fd, head, 0, 32, 0);
+            head = head.subarray(0, headLen);
+            const tailLen = Math.min(12, stat.size);
+            tail = Buffer.alloc(tailLen);
+            fs.readSync(fd, tail, 0, tailLen, stat.size - tailLen);
+        } finally {
+            fs.closeSync(fd);
+        }
+    } catch (err) {
+        deny('Image file is unreadable: ' + filePath + ' \u2014 ' + (err && err.message || err) + '. Skip reading it.');
+    }
+
+    const format = detectFormat(head);
+    if (!format) {
+        deny('Image file has invalid header \u2014 magic bytes do not match PNG/JPEG/GIF/WebP: ' + filePath + '. The file is corrupt or mislabeled. Skip reading it.');
+    }
+
+    const expectedExts = { png: ['.png'], jpeg: ['.jpg', '.jpeg'], gif: ['.gif'], webp: ['.webp'] }[format];
+    if (!expectedExts.includes(ext)) {
+        deny('Image file extension "' + ext + '" does not match actual format "' + format + '": ' + filePath + '. Skip reading it.');
+    }
+
+    const truncReason = checkTruncation(format, tail, stat.size, head);
+    if (truncReason) {
+        deny(truncReason + ' File: ' + filePath + '. Skip reading it.');
+    }
+})().catch(() => { /* never block on validator errors */ });
+`;
+
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname(__filename$1);
-const CLAUDE_SKILLS_DIR = join(os.homedir(), ".claude", "skills");
+const CLAUDE_SKILLS_DIR = join(os$1.homedir(), ".claude", "skills");
 async function installSkillFromEndpoint(name, baseUrl) {
   const resp = await fetch(baseUrl, { signal: AbortSignal.timeout(15e3) });
   if (!resp.ok) throw new Error(`HTTP ${resp.status} from ${baseUrl}`);
@@ -5820,14 +6076,14 @@ function loadEnvFile(path) {
   return true;
 }
 function loadDotEnv() {
-  const svampEnv = join(process.env.SVAMP_HOME || os.homedir() + "/.svamp", ".env");
+  const svampEnv = join(process.env.SVAMP_HOME || os$1.homedir() + "/.svamp", ".env");
   if (!loadEnvFile(svampEnv)) {
-    const hyphaEnv = join(process.env.HYPHA_HOME || os.homedir() + "/.hypha", ".env");
+    const hyphaEnv = join(process.env.HYPHA_HOME || os$1.homedir() + "/.hypha", ".env");
     loadEnvFile(hyphaEnv);
   }
 }
 loadDotEnv();
-const SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+const SVAMP_HOME = process.env.SVAMP_HOME || join(os$1.homedir(), ".svamp");
 const DAEMON_STATE_FILE = join(SVAMP_HOME, "daemon.state.json");
 const DAEMON_LOCK_FILE = join(SVAMP_HOME, "daemon.lock");
 const LOGS_DIR = join(SVAMP_HOME, "logs");
@@ -5941,7 +6197,7 @@ ${state.task}
 }
 function removeRalphState(filePath) {
   try {
-    unlinkSync(filePath);
+    unlinkSync$1(filePath);
   } catch {
   }
 }
@@ -6313,27 +6569,27 @@ function deletePersistedSession(sessionId) {
   if (entry) {
     const sessionFile = getSessionFilePath(entry.directory, sessionId);
     try {
-      if (existsSync$1(sessionFile)) unlinkSync(sessionFile);
+      if (existsSync$1(sessionFile)) unlinkSync$1(sessionFile);
     } catch {
     }
     const messagesFile = getSessionMessagesPath(entry.directory, sessionId);
     try {
-      if (existsSync$1(messagesFile)) unlinkSync(messagesFile);
+      if (existsSync$1(messagesFile)) unlinkSync$1(messagesFile);
     } catch {
     }
     const configFile = getSvampConfigPath(entry.directory, sessionId);
     try {
-      if (existsSync$1(configFile)) unlinkSync(configFile);
+      if (existsSync$1(configFile)) unlinkSync$1(configFile);
     } catch {
     }
     const ralphStateFile = getRalphStateFilePath(entry.directory, sessionId);
     try {
-      if (existsSync$1(ralphStateFile)) unlinkSync(ralphStateFile);
+      if (existsSync$1(ralphStateFile)) unlinkSync$1(ralphStateFile);
     } catch {
     }
     const ralphProgressFile = getRalphProgressFilePath(entry.directory, sessionId);
     try {
-      if (existsSync$1(ralphProgressFile)) unlinkSync(ralphProgressFile);
+      if (existsSync$1(ralphProgressFile)) unlinkSync$1(ralphProgressFile);
     } catch {
     }
     const sessionDir = getSessionDir(entry.directory, sessionId);
@@ -6603,7 +6859,7 @@ async function startDaemon(options) {
       machineId = readFileSync$1(machineIdFile, "utf-8").trim();
     }
     if (!machineId) {
-      machineId = `machine-${os.hostname()}-${randomUUID$1().slice(0, 8)}`;
+      machineId = `machine-${os$1.hostname()}-${randomUUID$1().slice(0, 8)}`;
       try {
         writeFileSync(machineIdFile, machineId, "utf-8");
       } catch {
@@ -6618,7 +6874,7 @@ async function startDaemon(options) {
   const supervisor = new ProcessSupervisor(join(SVAMP_HOME, "processes"));
   await supervisor.init();
   const tunnels = /* @__PURE__ */ new Map();
-  const { ServeManager } = await import('./serveManager-DOXI2QzY.mjs');
+  const { ServeManager } = await import('./serveManager-CUcu_V3q.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -6708,6 +6964,7 @@ async function startDaemon(options) {
         return await spawnAgentSession(sessionId, directory, agentName, options2, resumeSessionId);
       }
       let stagedCredentials = null;
+      let hookSettings = null;
       try {
         let parseBashPermission2 = function(permission) {
           if (permission === "Bash") return;
@@ -6792,10 +7049,10 @@ async function startDaemon(options) {
         var parseBashPermission = parseBashPermission2, shouldAutoAllow = shouldAutoAllow2, killAndWaitForExit = killAndWaitForExit2, buildIsolationConfig = buildIsolationConfig2;
         let sessionMetadata = {
           path: directory,
-          host: os.hostname(),
+          host: os$1.hostname(),
           version: "0.1.0",
           machineId,
-          homeDir: os.homedir(),
+          homeDir: os$1.homedir(),
           svampHomeDir: SVAMP_HOME,
           svampLibDir: join(__dirname$1, ".."),
           svampToolsDir: join(__dirname$1, "..", "tools"),
@@ -6916,10 +7173,22 @@ async function startDaemon(options) {
         let isSwitchingMode = false;
         let checkSvampConfig;
         let cleanupSvampConfig;
+        const VALID_CLAUDE_PERMISSION_MODES = /* @__PURE__ */ new Set(["default", "acceptEdits", "plan", "bypassPermissions"]);
         const CLAUDE_PERMISSION_MODE_MAP = {
-          "auto-approve-all": "bypassPermissions"
+          "auto-approve-all": "bypassPermissions",
+          "yolo": "bypassPermissions",
+          "safe-yolo": "acceptEdits",
+          "read-only": "plan"
+        };
+        const toClaudePermissionMode = (mode) => {
+          if (!mode) return "default";
+          const mapped = CLAUDE_PERMISSION_MODE_MAP[mode] ?? mode;
+          if (!VALID_CLAUDE_PERMISSION_MODES.has(mapped)) {
+            logger.log(`[Session ${sessionId}] Unknown permission mode '${mode}' \u2014 falling back to 'default'`);
+            return "default";
+          }
+          return mapped;
         };
-        const toClaudePermissionMode = (mode) => CLAUDE_PERMISSION_MODE_MAP[mode] || mode;
         const getActiveSecurityContext = () => sessionMetadata.securityContext ?? options2.securityContext;
         const shouldIsolateSession = () => shouldIsolate({
           forceIsolation: options2.forceIsolation,
@@ -6956,11 +7225,28 @@ async function startDaemon(options) {
           if (model) args.push("--model", model);
           if (appendSystemPrompt) args.push("--append-system-prompt", appendSystemPrompt);
           if (claudeResumeId) args.push("--resume", claudeResumeId);
+          if (!hookSettings) {
+            try {
+              hookSettings = generateHookSettings({ id: sessionId });
+              logger.log(`[Session ${sessionId}] Hook settings: ${hookSettings.settingsPath} (validator: ${hookSettings.validatorPath})`);
+            } catch (err) {
+              logger.log(`[Session ${sessionId}] Failed to generate hook settings: ${err?.message || err}`);
+            }
+          }
+          if (hookSettings) args.push("--settings", hookSettings.settingsPath);
           let spawnCommand = "claude";
           let spawnArgs = args;
           let extraEnv = {};
           isolationCleanupFiles = [];
           const isoConfig = buildIsolationConfig2(directory);
+          if (isoConfig && hookSettings) {
+            if (isoConfig.method === "nono") {
+              isoConfig.nonoConfig = isoConfig.nonoConfig || {};
+              const readFiles = isoConfig.nonoConfig.readFiles || [];
+              readFiles.push(hookSettings.validatorPath, hookSettings.settingsPath);
+              isoConfig.nonoConfig.readFiles = readFiles;
+            }
+          }
           if (isoConfig) {
             const wrapped = wrapWithIsolation(spawnCommand, spawnArgs, isoConfig);
             spawnCommand = wrapped.command;
@@ -7316,7 +7602,7 @@ ${progressContent}
 </system-reminder>
 
 The automated loop has finished. Review the progress above and let me know if you need anything else.`;
-                                      unlinkSync(progressPath);
+                                      unlinkSync$1(progressPath);
                                       logger.log(`[Session ${sessionId}] Injected progress file content and deleted ${progressPath}`);
                                     }
                                   }
@@ -7663,12 +7949,12 @@ The automated loop has finished. Review the progress above and let me know if yo
               } catch {
                 text = typeof content === "string" ? content : JSON.stringify(content);
               }
-              if (msgMeta?.permissionMode) {
-                currentPermissionMode = toClaudePermissionMode(msgMeta.permissionMode);
-                logger.log(`[Session ${sessionId}] Permission mode updated to: ${currentPermissionMode}`);
-              }
               if (msgMeta) {
-                lastSpawnMeta = { ...lastSpawnMeta, ...msgMeta };
+                const { permissionMode: incomingPermissionMode, ...safeMsgMeta } = msgMeta;
+                if (incomingPermissionMode && toClaudePermissionMode(incomingPermissionMode) !== currentPermissionMode) {
+                  logger.log(`[Session ${sessionId}] Ignoring meta.permissionMode='${incomingPermissionMode}' from sendMessage (current: ${currentPermissionMode}; use switchMode to change)`);
+                }
+                lastSpawnMeta = { ...lastSpawnMeta, ...safeMsgMeta };
               }
               if (isKillingClaude || isRestartingClaude || isSwitchingMode) {
                 logger.log(`[Session ${sessionId}] Message received while restarting Claude, queuing to prevent loss`);
@@ -7832,12 +8118,13 @@ The automated loop has finished. Review the progress above and let me know if yo
               }
             },
             onSwitchMode: async (mode) => {
-              logger.log(`[Session ${sessionId}] Switch mode: ${mode}`);
+              const normalizedMode = toClaudePermissionMode(mode);
+              logger.log(`[Session ${sessionId}] Switch mode: ${mode}${mode !== normalizedMode ? ` \u2192 ${normalizedMode}` : ""}`);
               if (isRestartingClaude || isSwitchingMode) {
                 logger.log(`[Session ${sessionId}] Switch mode deferred \u2014 restart/switch already in progress`);
                 return;
               }
-              currentPermissionMode = mode;
+              currentPermissionMode = normalizedMode;
               if (claudeProcess && claudeProcess.exitCode === null) {
                 isSwitchingMode = true;
                 isKillingClaude = true;
@@ -7845,7 +8132,7 @@ The automated loop has finished. Review the progress above and let me know if yo
                   await killAndWaitForExit2(claudeProcess);
                   isKillingClaude = false;
                   if (trackedSession?.stopped) return;
-                  spawnClaude(void 0, { permissionMode: mode });
+                  spawnClaude(void 0, { permissionMode: normalizedMode });
                 } finally {
                   isKillingClaude = false;
                   isSwitchingMode = false;
@@ -8142,6 +8429,12 @@ The automated loop has finished. Review the progress above and let me know if yo
           resumeSessionId: claudeResumeId,
           restartAgent: restartClaudeHandler,
           cleanupCredentials: stagedCredentials?.cleanup,
+          // Closure: hookSettings is generated lazily on first spawnClaude,
+          // after this trackedSession is registered, so resolve the current
+          // value at cleanup time rather than capturing null now.
+          cleanupHookSettings: () => {
+            hookSettings?.cleanup();
+          },
           get childProcess() {
             return claudeProcess || void 0;
           }
@@ -8161,6 +8454,8 @@ The automated loop has finished. Review the progress above and let me know if yo
           stagedCredentials.cleanup().catch(() => {
           });
         }
+        const hs = hookSettings;
+        if (hs) hs.cleanup();
         return {
           type: "error",
           errorMessage: `Failed to register session service: ${err?.message || String(err)}`
@@ -8200,10 +8495,10 @@ The automated loop has finished. Review the progress above and let me know if yo
         var parseBashPermission = parseBashPermission2, shouldAutoAllow = shouldAutoAllow2;
         let sessionMetadata = {
           path: directory,
-          host: os.hostname(),
+          host: os$1.hostname(),
           version: "0.1.0",
           machineId,
-          homeDir: os.homedir(),
+          homeDir: os$1.homedir(),
           svampHomeDir: SVAMP_HOME,
           svampLibDir: join(__dirname$1, ".."),
           svampToolsDir: join(__dirname$1, "..", "tools"),
@@ -8246,8 +8541,8 @@ The automated loop has finished. Review the progress above and let me know if yo
               } catch {
                 text = typeof content === "string" ? content : JSON.stringify(content);
               }
-              if (msgMeta?.permissionMode) {
-                currentPermissionMode = msgMeta.permissionMode;
+              if (msgMeta?.permissionMode && msgMeta.permissionMode !== currentPermissionMode) {
+                logger.log(`[${agentName} Session ${sessionId}] Ignoring meta.permissionMode='${msgMeta.permissionMode}' from sendMessage (current: ${currentPermissionMode}; use switchMode to change)`);
               }
               if (!acpBackendReady) {
                 logger.log(`[${agentName} Session ${sessionId}] Backend not ready \u2014 queuing message`);
@@ -8792,6 +9087,7 @@ The automated loop has finished. Review the progress above and let me know if yo
           }
           session.cleanupCredentials?.().catch(() => {
           });
+          session.cleanupHookSettings?.();
           session.cleanupSvampConfig?.();
           artifactSync.cancelSync(sessionId);
           pidToTrackedSession.delete(pid);
@@ -8824,14 +9120,14 @@ The automated loop has finished. Review the progress above and let me know if yo
       logger.log(`Failed to detect isolation capabilities: ${err}`);
       isolationCapabilities = { available: [], preferred: null, details: { nono: { found: false }, srt: { found: false }, bwrap: { found: false }, docker: { found: false }, podman: { found: false } } };
     }
-    const defaultHomeDir = existsSync$1("/data") ? "/data" : os.homedir();
+    const defaultHomeDir = existsSync$1("/data") ? "/data" : os$1.homedir();
     const persistedMachineMeta = loadPersistedMachineMetadata(SVAMP_HOME);
     if (persistedMachineMeta) {
       logger.log(`Restored machine metadata (sharing=${!!persistedMachineMeta.sharing}, securityContextConfig=${!!persistedMachineMeta.securityContextConfig}, injectPlatformGuidance=${persistedMachineMeta.injectPlatformGuidance})`);
     }
     const machineMetadata = {
-      host: os.hostname(),
-      platform: os.platform(),
+      host: os$1.hostname(),
+      platform: os$1.platform(),
       svampVersion: "0.1.0 (hypha)",
       homeDir: defaultHomeDir,
       svampHomeDir: SVAMP_HOME,
@@ -9111,6 +9407,7 @@ The automated loop has finished. Review the progress above and let me know if yo
               });
               session.cleanupCredentials?.().catch(() => {
               });
+              session.cleanupHookSettings?.();
               session.cleanupSvampConfig?.();
               if (session.svampSessionId) artifactSync.cancelSync(session.svampSessionId);
               pidToTrackedSession.delete(key);
@@ -9185,18 +9482,32 @@ The automated loop has finished. Review the progress above and let me know if yo
             }
           }
         }
-        const FRPC_FAILING_THRESHOLD_MS = 5 * 6e4;
+        const FRPC_FAILING_THRESHOLD_MS = 2 * 6e4;
+        const PROBE_STALENESS_THRESHOLD_MS = 2 * 6e4;
+        const tunnelLooksDead = (h) => {
+          if (h.failingDurationMs > FRPC_FAILING_THRESHOLD_MS) {
+            return `failing ${Math.round(h.failingDurationMs / 1e3)}s`;
+          }
+          if (h.probe && !h.probe.ok && h.probe.stalenessMs > PROBE_STALENESS_THRESHOLD_MS) {
+            return `probe stale ${Math.round(h.probe.stalenessMs / 1e3)}s`;
+          }
+          return null;
+        };
         const serveHealth = serveManager.getTunnelHealth();
-        if (serveHealth && serveHealth.failingDurationMs > FRPC_FAILING_THRESHOLD_MS) {
-          logger.log(`Serve manager tunnel failing for ${Math.round(serveHealth.failingDurationMs / 1e3)}s (${serveHealth.consecutiveErrors} errors, ${serveHealth.restartAttempts} restarts) \u2014 recreating`);
-          serveManager.recreateTunnel().catch((err) => {
-            logger.log(`Failed to recreate serve tunnel: ${err.message}`);
-          });
+        if (serveHealth) {
+          const reason = tunnelLooksDead(serveHealth);
+          if (reason) {
+            logger.log(`Serve manager tunnel ${reason} (${serveHealth.consecutiveErrors} errors, ${serveHealth.restartAttempts} restarts) \u2014 recreating`);
+            serveManager.recreateTunnel().catch((err) => {
+              logger.log(`Failed to recreate serve tunnel: ${err.message}`);
+            });
+          }
         }
         for (const [name, tunnel] of tunnels) {
           const health = tunnel.status;
-          if (health.failingDurationMs > FRPC_FAILING_THRESHOLD_MS) {
-            logger.log(`frpc tunnel '${name}' failing for ${Math.round(health.failingDurationMs / 1e3)}s \u2014 destroying stale tunnel`);
+          const reason = tunnelLooksDead(health);
+          if (reason) {
+            logger.log(`frpc tunnel '${name}' ${reason} \u2014 destroying stale tunnel`);
             tunnel.destroy();
             tunnels.delete(name);
           }
@@ -9533,7 +9844,7 @@ async function restartDaemon() {
 function daemonStatus() {
   const state = readDaemonStateFile();
   if (!state) {
-    const plistPath = join(os.homedir(), "Library", "LaunchAgents", "io.hypha.svamp.daemon.plist");
+    const plistPath = join(os$1.homedir(), "Library", "LaunchAgents", "io.hypha.svamp.daemon.plist");
     if (existsSync$1(plistPath)) {
       console.log("Status: Not running (launchd service installed \u2014 may be starting)");
     } else {
@@ -9572,4 +9883,4 @@ var run = /*#__PURE__*/Object.freeze({
     stopDaemon: stopDaemon
 });
 
-export { DefaultTransport$1 as D, GeminiTransport$1 as G, registerSessionService as a, stopDaemon as b, connectToHypha as c, daemonStatus as d, resolveSecurityContext as e, buildSecurityContextFromFlags as f, getHyphaServerUrl as g, acpBackend as h, acpAgentConfig as i, codexMcpBackend as j, claudeAuth as k, loadSecurityContextConfig as l, mergeSecurityContexts as m, run as n, registerMachineService as r, startDaemon as s };
+export { DefaultTransport$1 as D, GeminiTransport$1 as G, registerSessionService as a, stopDaemon as b, connectToHypha as c, daemonStatus as d, resolveSecurityContext as e, buildSecurityContextFromFlags as f, getHyphaServerUrl as g, generateHookSettings as h, acpBackend as i, acpAgentConfig as j, codexMcpBackend as k, loadSecurityContextConfig as l, mergeSecurityContexts as m, claudeAuth as n, run as o, registerMachineService as r, startDaemon as s };