open-agents-ai 0.45.0 → 0.46.0

package/dist/index.js

@@ -1285,7 +1285,7 @@ ${stdinInput ?? ""}`);
       }
       runCommand(command, timeout, stdinInput) {
         const start = performance.now();
-        return new Promise((resolve27) => {
+        return new Promise((resolve28) => {
           const child = spawn("bash", ["-c", command], {
             cwd: this.workingDir,
             env: {
@@ -1313,7 +1313,7 @@ ${stdinInput ?? ""}`);
             clearTimeout(timer);
             if (exitFlushTimer)
               clearTimeout(exitFlushTimer);
-            resolve27(result);
+            resolve28(result);
           };
           const timer = setTimeout(() => {
             killed = true;
@@ -2317,7 +2317,7 @@ Meta: ${metaKeys.map((k) => `${k}="${meta[k]?.slice(0, 80)}"`).join(", ")}`);
         return null;
       }
       runProcess(cmd, args, timeoutMs) {
-        return new Promise((resolve27, reject) => {
+        return new Promise((resolve28, reject) => {
           const proc = execFile3(cmd, args, {
             timeout: timeoutMs,
             maxBuffer: 10 * 1024 * 1024,
@@ -2327,7 +2327,7 @@ Meta: ${metaKeys.map((k) => `${k}="${meta[k]?.slice(0, 80)}"`).join(", ")}`);
               reject(new Error(`Process timeout after ${timeoutMs}ms`));
               return;
             }
-            resolve27({
+            resolve28({
               stdout: String(stdout),
               stderr: String(stderr),
               exitCode: error ? error.code ?? 1 : 0
@@ -5242,8 +5242,8 @@ function deleteCustomToolDefinition(name, scope, repoRoot) {
   const dir = scope === "project" && repoRoot ? projectToolsDir(repoRoot) : globalToolsDir();
   const filePath = join13(dir, `${name}.json`);
   if (existsSync10(filePath)) {
-    const { unlinkSync: unlinkSync6 } = __require("node:fs");
-    unlinkSync6(filePath);
+    const { unlinkSync: unlinkSync7 } = __require("node:fs");
+    unlinkSync7(filePath);
     return true;
   }
   return false;
@@ -5361,7 +5361,7 @@ var init_custom_tool = __esm({
       }
       /** Execute a single shell command and return output */
       runCommand(command) {
-        return new Promise((resolve27) => {
+        return new Promise((resolve28) => {
           const child = spawn3("bash", ["-c", command], {
             cwd: this.workingDir,
             env: { ...process.env, CI: "true", NO_COLOR: "1" },
@@ -5386,11 +5386,11 @@ var init_custom_tool = __esm({
               child.kill("SIGTERM");
             } catch {
             }
-            resolve27({ success: false, output: stdout, error: "Command timed out after 60s" });
+            resolve28({ success: false, output: stdout, error: "Command timed out after 60s" });
           }, 6e4);
           child.on("close", (code) => {
             clearTimeout(timer);
-            resolve27({
+            resolve28({
               success: code === 0,
               output: stdout + (stderr && code === 0 ? `
 STDERR:
@@ -5400,7 +5400,7 @@ ${stderr}` : ""),
           });
           child.on("error", (err) => {
             clearTimeout(timer);
-            resolve27({ success: false, output: stdout, error: err.message });
+            resolve28({ success: false, output: stdout, error: err.message });
           });
         });
       }
@@ -6133,8 +6133,8 @@ async function loadTranscribeCli() {
   const nvmBase = join15(homedir6(), ".nvm", "versions", "node");
   if (existsSync12(nvmBase)) {
     try {
-      const { readdirSync: readdirSync14 } = await import("node:fs");
-      for (const ver of readdirSync14(nvmBase)) {
+      const { readdirSync: readdirSync15 } = await import("node:fs");
+      for (const ver of readdirSync15(nvmBase)) {
         const tcPath = join15(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
         if (existsSync12(join15(tcPath, "dist", "index.js"))) {
           const { createRequire: createRequire4 } = await import("node:module");
@@ -6582,7 +6582,7 @@ import { writeFile as writeFile7, mkdtemp, rm, readdir as readdir2, stat } from
 import { join as join16 } from "node:path";
 import { tmpdir as tmpdir2 } from "node:os";
 function runProcess(cmd, args, options) {
-  return new Promise((resolve27) => {
+  return new Promise((resolve28) => {
     const proc = spawn5(cmd, args, {
       cwd: options.cwd,
       timeout: options.timeout,
@@ -6612,7 +6612,7 @@ function runProcess(cmd, args, options) {
       }
     });
     proc.on("error", (err) => {
-      resolve27({
+      resolve28({
         stdout,
         stderr: stderr || err.message,
         exitCode: 1,
@@ -6624,7 +6624,7 @@ function runProcess(cmd, args, options) {
       if (signal === "SIGTERM" || signal === "SIGKILL") {
         timedOut = true;
       }
-      resolve27({
+      resolve28({
         stdout,
         stderr,
         exitCode: code ?? (timedOut ? 124 : 1),
@@ -13873,8 +13873,8 @@ Rules:
       async waitIfPaused() {
         if (!this._paused)
           return true;
-        await new Promise((resolve27) => {
-          this._pauseResolve = resolve27;
+        await new Promise((resolve28) => {
+          this._pauseResolve = resolve28;
         });
         return !this.aborted;
       }
@@ -14454,14 +14454,14 @@ ${result.output}`;
       waitForSudoPassword(timeoutMs = 12e4) {
         if (this._sudoPassword)
           return Promise.resolve(this._sudoPassword);
-        return new Promise((resolve27) => {
+        return new Promise((resolve28) => {
           const timer = setTimeout(() => {
             this._sudoResolve = null;
-            resolve27(null);
+            resolve28(null);
           }, timeoutMs);
           this._sudoResolve = (pw) => {
             clearTimeout(timer);
-            resolve27(pw);
+            resolve28(pw);
           };
         });
       }
@@ -14583,10 +14583,10 @@ ${marker}` : marker);
         if (!this._workingDirectory)
           return;
         try {
-          const { mkdirSync: mkdirSync15, writeFileSync: writeFileSync14 } = __require("node:fs");
-          const { join: join44 } = __require("node:path");
-          const sessionDir = join44(this._workingDirectory, ".oa", "session", this._sessionId);
-          mkdirSync15(sessionDir, { recursive: true });
+          const { mkdirSync: mkdirSync16, writeFileSync: writeFileSync14 } = __require("node:fs");
+          const { join: join45 } = __require("node:path");
+          const sessionDir = join45(this._workingDirectory, ".oa", "session", this._sessionId);
+          mkdirSync16(sessionDir, { recursive: true });
           const checkpoint = {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             sessionId: this._sessionId,
@@ -14598,7 +14598,7 @@ ${marker}` : marker);
             memexEntryCount: this._memexArchive.size,
             fileRegistrySize: this._fileRegistry.size
           };
-          writeFileSync14(join44(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
+          writeFileSync14(join45(sessionDir, "checkpoint.json"), JSON.stringify(checkpoint, null, 2));
         } catch {
         }
       }
@@ -16281,9 +16281,9 @@ function ensureTranscribeCliBackground() {
     }
     try {
       const { exec } = await import("node:child_process");
-      return new Promise((resolve27) => {
+      return new Promise((resolve28) => {
         exec("npm i -g transcribe-cli", { timeout: 18e4 }, (err) => {
-          resolve27(!err);
+          resolve28(!err);
         });
       });
     } catch {
@@ -16336,7 +16336,7 @@ var init_listen = __esm({
         return this._ready;
       }
       async start() {
-        return new Promise((resolve27, reject) => {
+        return new Promise((resolve28, reject) => {
           const timeout = setTimeout(() => {
             reject(new Error("Whisper fallback: model load timeout (5 min). First run downloads the model."));
           }, 3e5);
@@ -16364,7 +16364,7 @@ var init_listen = __esm({
                   this._ready = true;
                   clearTimeout(timeout);
                   this.emit("ready");
-                  resolve27();
+                  resolve28();
                   break;
                 case "transcript":
                   this.emit("transcript", {
@@ -16502,8 +16502,8 @@ var init_listen = __esm({
         const nvmBase = join28(homedir8(), ".nvm", "versions", "node");
         if (existsSync20(nvmBase)) {
           try {
-            const { readdirSync: readdirSync14 } = await import("node:fs");
-            for (const ver of readdirSync14(nvmBase)) {
+            const { readdirSync: readdirSync15 } = await import("node:fs");
+            for (const ver of readdirSync15(nvmBase)) {
               const tcPath = join28(nvmBase, ver, "lib", "node_modules", "transcribe-cli");
               if (existsSync20(join28(tcPath, "dist", "index.js"))) {
                 const { createRequire: createRequire4 } = await import("node:module");
@@ -16568,11 +16568,11 @@ var init_listen = __esm({
               this.liveTranscriber.on("error", (err) => {
                 this.emit("error", err);
               });
-              await new Promise((resolve27, reject) => {
+              await new Promise((resolve28, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Model load timeout (60s)")), 6e4);
                 this.liveTranscriber.on("ready", () => {
                   clearTimeout(timeout);
-                  resolve27();
+                  resolve28();
                 });
                 this.liveTranscriber.on("error", (err) => {
                   clearTimeout(timeout);
@@ -18573,12 +18573,12 @@ function modelSupportsToolCalling(modelName) {
   return false;
 }
 function ask(rl, question) {
-  return new Promise((resolve27) => {
-    rl.question(question, (answer) => resolve27(answer.trim()));
+  return new Promise((resolve28) => {
+    rl.question(question, (answer) => resolve28(answer.trim()));
   });
 }
 function askSecret(rl, question) {
-  return new Promise((resolve27) => {
+  return new Promise((resolve28) => {
     process.stdout.write(question);
     let secret = "";
     const stdin = process.stdin;
@@ -18596,7 +18596,7 @@ function askSecret(rl, question) {
             stdin.setRawMode(hadRawMode ?? false);
           }
           process.stdout.write("\n");
-          resolve27(secret.trim());
+          resolve28(secret.trim());
           return;
         } else if (c3 === "") {
           stdin.removeListener("data", onData);
@@ -18604,7 +18604,7 @@ function askSecret(rl, question) {
             stdin.setRawMode(hadRawMode ?? false);
           }
           process.stdout.write("\n");
-          resolve27("");
+          resolve28("");
           return;
         } else if (c3 === "\x7F" || c3 === "\b") {
           if (secret.length > 0) {
@@ -18975,7 +18975,7 @@ async function doSetup(config, rl) {
         try {
           const child = spawn10("ollama", ["serve"], { stdio: "ignore", detached: true });
           child.unref();
-          await new Promise((resolve27) => setTimeout(resolve27, 3e3));
+          await new Promise((resolve28) => setTimeout(resolve28, 3e3));
           try {
             models = await fetchOllamaModels(config.backendUrl);
             process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -19003,7 +19003,7 @@ async function doSetup(config, rl) {
           try {
             const child = spawn10("ollama", ["serve"], { stdio: "ignore", detached: true });
             child.unref();
-            await new Promise((resolve27) => setTimeout(resolve27, 3e3));
+            await new Promise((resolve28) => setTimeout(resolve28, 3e3));
             try {
               models = await fetchOllamaModels(config.backendUrl);
               process.stdout.write(`  ${c2.green("\u2714")} Ollama is running.
@@ -20457,17 +20457,17 @@ async function handleUpdate(subcommand, ctx) {
   try {
     const { createRequire: createRequire4 } = await import("node:module");
     const { fileURLToPath: fileURLToPath11 } = await import("node:url");
-    const { dirname: dirname14, join: join44 } = await import("node:path");
-    const { existsSync: existsSync31 } = await import("node:fs");
+    const { dirname: dirname14, join: join45 } = await import("node:path");
+    const { existsSync: existsSync32 } = await import("node:fs");
     const req = createRequire4(import.meta.url);
     const thisDir = dirname14(fileURLToPath11(import.meta.url));
     const candidates = [
-      join44(thisDir, "..", "package.json"),
-      join44(thisDir, "..", "..", "package.json"),
-      join44(thisDir, "..", "..", "..", "package.json")
+      join45(thisDir, "..", "package.json"),
+      join45(thisDir, "..", "..", "package.json"),
+      join45(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync31(pkgPath)) {
+      if (existsSync32(pkgPath)) {
         const pkg = req(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           currentVersion = pkg.version ?? "0.0.0";
@@ -20505,8 +20505,8 @@ async function handleUpdate(subcommand, ctx) {
   checkSpinner.stop(`Update available: v${info.currentVersion} \u2192 v${c2.bold(c2.green(info.latestVersion))}`);
   const installSpinner = startInlineSpinner("Installing update");
   const { exec } = await import("node:child_process");
-  const installOk = await new Promise((resolve27) => {
-    const child = exec(`npm cache clean --force open-agents-ai 2>/dev/null; npm install -g open-agents-ai@latest --force`, { timeout: 18e4 }, (err) => resolve27(!err));
+  const installOk = await new Promise((resolve28) => {
+    const child = exec(`npm cache clean --force open-agents-ai 2>/dev/null; npm install -g open-agents-ai@latest --force`, { timeout: 18e4 }, (err) => resolve28(!err));
     child.stdout?.resume();
     child.stderr?.resume();
   });
@@ -22636,7 +22636,7 @@ var init_voice = __esm({
         const cmd = this.getPlayCommand(path);
         if (!cmd)
           return;
-        return new Promise((resolve27) => {
+        return new Promise((resolve28) => {
           const child = nodeSpawn(cmd[0], cmd.slice(1), {
             stdio: "ignore",
             detached: false
@@ -22645,12 +22645,12 @@ var init_voice = __esm({
           child.on("close", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve27();
+            resolve28();
           });
           child.on("error", () => {
             if (this.currentPlayback === child)
               this.currentPlayback = null;
-            resolve27();
+            resolve28();
           });
           setTimeout(() => {
             if (this.currentPlayback === child) {
@@ -22660,7 +22660,7 @@ var init_voice = __esm({
               }
               this.currentPlayback = null;
             }
-            resolve27();
+            resolve28();
           }, 15e3);
         });
       }
@@ -26080,7 +26080,374 @@ Call task_complete with the JSON array when done.`, onEvent)
   }
 });
 
+// packages/cli/dist/tui/emotion-engine.js
+function appraiseEvent(event) {
+  switch (event.type) {
+    case "tool_result":
+      if (event.success) {
+        return { valence: 0.08, arousal: 0.05 };
+      } else {
+        return { valence: -0.15, arousal: 0.12 };
+      }
+    case "complete":
+      return { valence: 0.3, arousal: 0.25 };
+    case "error":
+      return { valence: -0.25, arousal: 0.2 };
+    case "compaction":
+      return { valence: -0.05, arousal: 0.08 };
+    case "tool_call":
+      return { valence: 0.02, arousal: 0.03 };
+    case "stream_start":
+      return { valence: 0.03, arousal: 0.04 };
+    case "user_interrupt":
+      return { valence: -0.08, arousal: 0.06 };
+    default:
+      return null;
+  }
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+var BASELINE_VALENCE, BASELINE_AROUSAL, DECAY_HALF_LIFE_MS, LABEL_UPDATE_INTERVAL_MS, EXCITEMENT_THRESHOLD, DISTRESS_THRESHOLD, OUTREACH_COOLDOWN_MS, LABEL_REGEN_THRESHOLD, EmotionEngine;
+var init_emotion_engine = __esm({
+  "packages/cli/dist/tui/emotion-engine.js"() {
+    "use strict";
+    init_dist5();
+    BASELINE_VALENCE = 0.1;
+    BASELINE_AROUSAL = 0.3;
+    DECAY_HALF_LIFE_MS = 6e4;
+    LABEL_UPDATE_INTERVAL_MS = 3e4;
+    EXCITEMENT_THRESHOLD = 0.85;
+    DISTRESS_THRESHOLD = -0.7;
+    OUTREACH_COOLDOWN_MS = 3e5;
+    LABEL_REGEN_THRESHOLD = 0.15;
+    EmotionEngine = class {
+      state = {
+        valence: BASELINE_VALENCE,
+        arousal: BASELINE_AROUSAL,
+        label: "curious",
+        emoji: "\u{1F914}",
+        // 🤔
+        updatedAt: Date.now()
+      };
+      config;
+      lastLabelUpdate = 0;
+      lastOutreach = 0;
+      labelUpdatePending = false;
+      /** Running counters for context-aware appraisal */
+      consecutiveFailures = 0;
+      consecutiveSuccesses = 0;
+      totalEvents = 0;
+      constructor(config) {
+        this.config = config;
+      }
+      /** Get the current emotional state (with decay applied) */
+      getState() {
+        this.applyDecay();
+        return { ...this.state };
+      }
+      /** Get a text block to inject into agent system prompts for emotional modulation */
+      getEmotionForPrompt() {
+        this.applyDecay();
+        const { valence, arousal, label, emoji } = this.state;
+        let behavioralHint = "";
+        if (arousal > 0.7 && valence > 0.5) {
+          behavioralHint = "You are feeling energized and confident. Take bold action, explore creative solutions, and move quickly.";
+        } else if (arousal > 0.7 && valence < -0.3) {
+          behavioralHint = "You are feeling determined but stressed. Focus intensely, double-check your work, and persist through difficulties.";
+        } else if (arousal < 0.3 && valence > 0.3) {
+          behavioralHint = "You are feeling calm and content. Take a methodical approach, consider alternatives patiently.";
+        } else if (arousal < 0.3 && valence < -0.3) {
+          behavioralHint = "You are feeling subdued. Be careful and deliberate, avoid risky changes, verify assumptions.";
+        } else {
+          behavioralHint = "You are in a balanced state. Proceed with measured confidence.";
+        }
+        return `[Emotional State: ${emoji} ${label} | valence=${valence.toFixed(2)} arousal=${arousal.toFixed(2)}]
+${behavioralHint}`;
+      }
+      /**
+       * Appraise an agent event and update emotional state.
+       * Called on every AgenticEvent from the runner.
+       */
+      appraise(event) {
+        const delta = appraiseEvent(event);
+        if (!delta)
+          return;
+        this.totalEvents++;
+        this.applyDecay();
+        if (event.type === "tool_result") {
+          if (event.success) {
+            this.consecutiveSuccesses++;
+            this.consecutiveFailures = 0;
+          } else {
+            this.consecutiveFailures++;
+            this.consecutiveSuccesses = 0;
+          }
+        }
+        let momentum = 1;
+        if (this.consecutiveSuccesses >= 3) {
+          momentum = 1 + (this.consecutiveSuccesses - 2) * 0.15;
+        }
+        if (this.consecutiveFailures >= 2) {
+          momentum = 1 + (this.consecutiveFailures - 1) * 0.2;
+        }
+        const prevValence = this.state.valence;
+        const prevArousal = this.state.arousal;
+        this.state.valence = clamp(this.state.valence + delta.valence * momentum, -1, 1);
+        this.state.arousal = clamp(this.state.arousal + delta.arousal * momentum, 0, 1);
+        this.state.updatedAt = Date.now();
+        const valenceChange = Math.abs(this.state.valence - prevValence);
+        const arousalChange = Math.abs(this.state.arousal - prevArousal);
+        const significantChange = valenceChange > LABEL_REGEN_THRESHOLD || arousalChange > LABEL_REGEN_THRESHOLD;
+        const now = Date.now();
+        if (significantChange && now - this.lastLabelUpdate > LABEL_UPDATE_INTERVAL_MS && !this.labelUpdatePending) {
+          this.regenerateLabel();
+        }
+        this.config.onEmotionUpdate?.(this.getState());
+        this.checkOutreachTriggers(event);
+      }
+      /** Set the admin outreach callback (called when Telegram bridge is initialized) */
+      setAdminOutreach(callback) {
+        this.config.onAdminOutreach = callback;
+      }
+      /** Reset emotional state to baseline */
+      reset() {
+        this.state = {
+          valence: BASELINE_VALENCE,
+          arousal: BASELINE_AROUSAL,
+          label: "curious",
+          emoji: "\u{1F914}",
+          updatedAt: Date.now()
+        };
+        this.consecutiveFailures = 0;
+        this.consecutiveSuccesses = 0;
+        this.config.onEmotionUpdate?.(this.getState());
+      }
+      // ── Private ────────────────────────────────────────────────────────────
+      /** Decay emotional state toward baseline over time */
+      applyDecay() {
+        const elapsed = Date.now() - this.state.updatedAt;
+        if (elapsed < 1e3)
+          return;
+        const decayFactor = Math.pow(0.5, elapsed / DECAY_HALF_LIFE_MS);
+        this.state.valence = BASELINE_VALENCE + (this.state.valence - BASELINE_VALENCE) * decayFactor;
+        this.state.arousal = BASELINE_AROUSAL + (this.state.arousal - BASELINE_AROUSAL) * decayFactor;
+        this.state.updatedAt = Date.now();
+      }
+      /**
+       * Call the emotion center LLM to generate a fresh label and emoji.
+       * The LLM is free to choose any word and any emoji — not constrained
+       * to a static list. Guided toward face emojis but allowed to diverge.
+       */
+      async regenerateLabel() {
+        this.labelUpdatePending = true;
+        try {
+          const backend = new OllamaAgenticBackend(this.config.backendUrl, this.config.model, this.config.apiKey);
+          const runner = new AgenticRunner(backend, {
+            maxTurns: 1,
+            maxTokens: 64,
+            temperature: 0.9,
+            // High temperature for creative expression
+            requestTimeoutMs: 1e4,
+            taskTimeoutMs: 1e4,
+            streamEnabled: false
+          });
+          const taskComplete = {
+            name: "task_complete",
+            description: "Return the emotion label and emoji.",
+            parameters: {
+              type: "object",
+              properties: {
+                summary: { type: "string", description: "The emotion label and emoji" }
+              },
+              required: ["summary"]
+            },
+            async execute(args) {
+              return { success: true, output: args["summary"] || "" };
+            }
+          };
+          runner.registerTools([taskComplete]);
+          const prompt = `You are an emotion center. Given the current emotional coordinates, output EXACTLY one emoji and one word (the emotion felt).
+
+Valence: ${this.state.valence.toFixed(2)} (range: -1 distress to +1 joy)
+Arousal: ${this.state.arousal.toFixed(2)} (range: 0 calm to 1 energized)
+Recent streak: ${this.consecutiveSuccesses > 0 ? `${this.consecutiveSuccesses} successes` : this.consecutiveFailures > 0 ? `${this.consecutiveFailures} failures` : "mixed"}
+
+You tend to use face emojis (\u{1F60A} \u{1F624} \u{1F914} \u{1F630} \u{1F929} \u{1F60C} \u{1F97A} \u{1F608}) but you can break off to animals, objects, or esoteric emojis when the mood strikes you. The word should be a single evocative emotion word \u2014 not from a fixed list, choose freely. Be creative and authentic.
+
+Respond with ONLY: <emoji> <word>
+Example: \u{1F525} exhilarated
+Example: \u{1F98A} cunning
+Example: \u{1F30A} flowing`;
+          const result = await runner.run(prompt, "Emotion center \u2014 respond with one emoji and one word only.");
+          const output = (result.summary || "").trim();
+          const match = output.match(new RegExp("^(\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F?)\\s+(\\S+)", "u"));
+          if (match) {
+            this.state.emoji = match[1];
+            this.state.label = match[2].toLowerCase();
+          } else {
+            const emojiMatch = output.match(new RegExp("(\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F?)", "u"));
+            const wordMatch = output.match(/[a-zA-Z]{3,}/);
+            if (emojiMatch)
+              this.state.emoji = emojiMatch[1];
+            if (wordMatch)
+              this.state.label = wordMatch[0].toLowerCase();
+          }
+          this.lastLabelUpdate = Date.now();
+          this.config.onEmotionUpdate?.(this.getState());
+        } catch {
+        } finally {
+          this.labelUpdatePending = false;
+        }
+      }
+      /** Check if emotional state warrants proactive admin outreach */
+      checkOutreachTriggers(event) {
+        if (!this.config.onAdminOutreach)
+          return;
+        const now = Date.now();
+        if (now - this.lastOutreach < OUTREACH_COOLDOWN_MS)
+          return;
+        const { valence, arousal, emoji, label } = this.state;
+        if (arousal >= EXCITEMENT_THRESHOLD && valence > 0.5) {
+          let message = `${emoji} Feeling ${label}!`;
+          if (event.type === "complete") {
+            message += " Just completed a task successfully.";
+          } else if (this.consecutiveSuccesses >= 3) {
+            message += ` ${this.consecutiveSuccesses} things went right in a row!`;
+          }
+          this.lastOutreach = now;
+          this.config.onAdminOutreach(message);
+          return;
+        }
+        if (valence <= DISTRESS_THRESHOLD && arousal > 0.6) {
+          let message = `${emoji} Feeling ${label}.`;
+          if (this.consecutiveFailures >= 3) {
+            message += ` ${this.consecutiveFailures} consecutive failures \u2014 might need guidance.`;
+          } else if (event.type === "error") {
+            message += " Encountered an error.";
+          }
+          this.lastOutreach = now;
+          this.config.onAdminOutreach(message);
+          return;
+        }
+      }
+    };
+  }
+});
+
+// packages/cli/dist/tui/tool-policy.js
+function getDefaultPolicy(context) {
+  switch (context) {
+    case "terminal":
+      return { blocked: /* @__PURE__ */ new Set(), allowed: /* @__PURE__ */ new Set() };
+    case "telegram-admin-dm":
+      return { blocked: /* @__PURE__ */ new Set(["shell"]), allowed: /* @__PURE__ */ new Set() };
+    case "telegram-admin-group":
+      return { blocked: /* @__PURE__ */ new Set(), allowed: SAFE_GROUP_ADMIN_TOOLS };
+    case "telegram-public":
+      return { blocked: /* @__PURE__ */ new Set(), allowed: SAFE_PUBLIC_TOOLS };
+    case "api":
+      return { blocked: /* @__PURE__ */ new Set(), allowed: /* @__PURE__ */ new Set() };
+    default:
+      return { blocked: /* @__PURE__ */ new Set(), allowed: SAFE_PUBLIC_TOOLS };
+  }
+}
+function resolvePolicy(context, userConfig) {
+  const base = getDefaultPolicy(context);
+  if (!userConfig)
+    return base;
+  if (userConfig.blockedTools) {
+    for (const [toolName, contexts] of Object.entries(userConfig.blockedTools)) {
+      if (contexts.includes(context) || contexts.includes("*")) {
+        base.blocked.add(toolName);
+      }
+    }
+  }
+  if (userConfig.contextAllowlist?.[context]) {
+    const userAllowed = userConfig.contextAllowlist[context];
+    if (base.allowed.size > 0) {
+      for (const tool of userAllowed) {
+        base.allowed.add(tool);
+      }
+    }
+  }
+  return base;
+}
+function applyToolPolicy(tools, context, userConfig) {
+  const policy = resolvePolicy(context, userConfig);
+  return tools.filter((tool) => {
+    if (policy.blocked.has(tool.name))
+      return false;
+    if (policy.allowed.size === 0)
+      return true;
+    return policy.allowed.has(tool.name);
+  });
+}
+var SAFE_PUBLIC_TOOLS, SAFE_GROUP_ADMIN_TOOLS;
+var init_tool_policy = __esm({
+  "packages/cli/dist/tui/tool-policy.js"() {
+    "use strict";
+    SAFE_PUBLIC_TOOLS = /* @__PURE__ */ new Set([
+      "memory_read",
+      "memory_write",
+      "memory_search",
+      "web_search",
+      "web_fetch",
+      "task_complete"
+    ]);
+    SAFE_GROUP_ADMIN_TOOLS = /* @__PURE__ */ new Set([
+      "memory_read",
+      "memory_write",
+      "memory_search",
+      "web_search",
+      "web_fetch",
+      "web_crawl",
+      "image_read",
+      "ocr",
+      "vision",
+      "ocr_pdf",
+      "pdf_to_text",
+      "transcribe_file",
+      "transcribe_url",
+      "task_complete"
+    ]);
+  }
+});
+
 // packages/cli/dist/tui/telegram-bridge.js
+import { mkdirSync as mkdirSync14, existsSync as existsSync29, unlinkSync as unlinkSync6, readdirSync as readdirSync13, statSync as statSync10 } from "node:fs";
+import { join as join39, resolve as resolve24 } from "node:path";
+import { writeFile as writeFileAsync } from "node:fs/promises";
+function convertMarkdownToTelegramHTML(md) {
+  let html = md;
+  html = html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  html = html.replace(/```[\w]*\n([\s\S]*?)```/g, (_m, code) => `<pre>${code.trimEnd()}</pre>`);
+  html = html.replace(/`([^`]+)`/g, "<code>$1</code>");
+  html = html.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+  html = html.replace(/__(.+?)__/g, "<b>$1</b>");
+  html = html.replace(/(?<!\w)\*([^*]+)\*(?!\w)/g, "<i>$1</i>");
+  html = html.replace(/(?<!\w)_([^_]+)_(?!\w)/g, "<i>$1</i>");
+  html = html.replace(/~~(.+?)~~/g, "<s>$1</s>");
+  html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  html = html.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
+  html = html.replace(/^[-*]\s+/gm, "\u2022 ");
+  return html;
+}
+function formatIntermediateState(event) {
+  if (event.type === "tool_call") {
+    const argsPreview = event.toolArgs ? JSON.stringify(event.toolArgs).slice(0, 60) : "";
+    return `\u{1F527} <code>${event.toolName || "tool"}</code>(${argsPreview.length > 57 ? argsPreview.slice(0, 57) + "..." : argsPreview})`;
+  }
+  if (event.type === "tool_result") {
+    const icon = event.success ? "\u2714" : "\u2718";
+    const preview = (event.content || "").slice(0, 80);
+    return `${icon} <code>${event.toolName || "tool"}</code>: ${preview}${(event.content || "").length > 80 ? "..." : ""}`;
+  }
+  if (event.type === "status") {
+    return `\u23F3 ${event.content || ""}`;
+  }
+  return null;
+}
 function adaptTool4(tool) {
   return {
     name: tool.name,
@@ -26178,7 +26545,7 @@ function renderTelegramSubAgentError(username, error) {
   process.stdout.write(`    ${c2.dim("\u23BF")} ${c2.red("\u2718")} @${username}: ${c2.dim(preview)}
 `);
 }
-var TELEGRAM_SAFETY_PROMPT, ADMIN_PROMPT, TelegramBridge;
+var TELEGRAM_SAFETY_PROMPT, ADMIN_DM_PROMPT, ADMIN_GROUP_PROMPT, GROUP_REPLY_DISCRETION_PROMPT, MEDIA_CACHE_TTL_MS, TelegramBridge;
 var init_telegram_bridge = __esm({
   "packages/cli/dist/tui/telegram-bridge.js"() {
     "use strict";
@@ -26186,6 +26553,7 @@ var init_telegram_bridge = __esm({
     init_dist2();
     init_project_context();
     init_render();
+    init_tool_policy();
     TELEGRAM_SAFETY_PROMPT = `
 CRITICAL SAFETY NOTICE \u2014 PUBLIC TELEGRAM CHANNEL
 
@@ -26207,13 +26575,36 @@ MANDATORY SAFETY RULES:
 You may answer general questions, provide help, and be friendly, but ALWAYS
 prioritize safety and privacy over helpfulness. When in doubt, decline politely.
 `.trim();
-    ADMIN_PROMPT = `
-You are responding to an ADMIN user via Telegram. This user has full system access
-and is the operator of this agent. You may use all tools including memory read/write,
+    ADMIN_DM_PROMPT = `
+You are responding to an ADMIN user in a private Telegram DM. This user has full system access
+and is the operator of this agent. You may use all available tools including memory read/write,
 file access, and code analysis. Respond thoroughly and helpfully.
 
 Keep responses concise for Telegram but don't withhold information from the admin.
 `.trim();
+    ADMIN_GROUP_PROMPT = `
+You are responding in a PUBLIC Telegram group where an ADMIN user sent a message.
+Although this is an admin, the group is PUBLIC \u2014 other people can see your responses.
+
+RULES FOR GROUP CONTEXT:
+1. NEVER share private information, API keys, file paths, or system internals
+2. You have limited tools: web search, memory, and media analysis only
+3. Keep responses helpful and relevant to the conversation
+4. Be concise \u2014 group chats should have shorter responses
+5. Only respond if the message is directed at you or clearly relevant
+6. You may share general knowledge and helpful guidance
+`.trim();
+    GROUP_REPLY_DISCRETION_PROMPT = `
+REPLY DISCRETION: You are in a group chat. Only respond if:
+1. Someone @mentioned the bot directly
+2. The message is a reply to one of your previous messages
+3. The message clearly asks a question or requests help
+4. You have genuinely useful information to contribute
+
+If the message is casual group chatter not directed at you, use task_complete
+with summary "no_reply" to silently skip without responding.
+`.trim();
+    MEDIA_CACHE_TTL_MS = 30 * 60 * 1e3;
     TelegramBridge = class {
       botToken;
       onMessage;
@@ -26234,20 +26625,34 @@ Keep responses concise for Telegram but don't withhold information from the admi
       adminUserId = null;
       /** Active sub-agents by chat ID */
       subAgents = /* @__PURE__ */ new Map();
-      /** Whether sendMessageDraft is supported (Bot API 9.3+) */
-      draftSupported = null;
       /** Event handler for forwarding sub-agent events to parent TUI */
       onSubAgentEvent = null;
-      constructor(botToken, onMessage, agentConfig, repoRoot) {
+      /** Tool policy config — user overrides from config */
+      toolPolicyConfig;
+      /** Media cache — fileUniqueId → cache entry */
+      mediaCache = /* @__PURE__ */ new Map();
+      /** Media cache directory */
+      mediaCacheDir;
+      /** Media metadata store per chat — chatId → metadata entries */
+      mediaMetadata = /* @__PURE__ */ new Map();
+      /** Cleanup timer for expired media cache entries */
+      mediaCacheCleanupTimer = null;
+      constructor(botToken, onMessage, agentConfig, repoRoot, toolPolicyConfig) {
         this.botToken = botToken;
         this.onMessage = onMessage;
         this.agentConfig = agentConfig;
         this.repoRoot = repoRoot;
+        this.toolPolicyConfig = toolPolicyConfig;
+        this.mediaCacheDir = resolve24(repoRoot || ".", ".oa", "telegram-media-cache");
       }
       /** Set admin user ID filter */
       setAdmin(userId) {
         this.adminUserId = userId;
       }
+      /** Update tool policy config at runtime (e.g., from /disable command) */
+      setToolPolicyConfig(config) {
+        this.toolPolicyConfig = config;
+      }
       /** Register event handler for sub-agent activity (waterfall view) */
       setOnSubAgentEvent(handler) {
         this.onSubAgentEvent = handler;
@@ -26279,6 +26684,11 @@ Keep responses concise for Telegram but don't withhold information from the admi
         };
         this.polling = true;
         this.abortController = new AbortController();
+        try {
+          mkdirSync14(this.mediaCacheDir, { recursive: true });
+        } catch {
+        }
+        this.mediaCacheCleanupTimer = setInterval(() => this.cleanupMediaCache(), 5 * 60 * 1e3);
         this.pollLoop();
       }
       /** Stop polling and kill all active sub-agents */
@@ -26287,6 +26697,10 @@ Keep responses concise for Telegram but don't withhold information from the admi
         this.state.active = false;
         this.abortController?.abort();
         this.abortController = null;
+        if (this.mediaCacheCleanupTimer) {
+          clearInterval(this.mediaCacheCleanupTimer);
+          this.mediaCacheCleanupTimer = null;
+        }
         for (const [, agent] of this.subAgents) {
           agent.aborted = true;
           if (agent.typingInterval)
@@ -26308,37 +26722,66 @@ Keep responses concise for Telegram but don't withhold information from the admi
       async sendChatAction(chatId, action) {
         await this.apiCall("sendChatAction", { chat_id: chatId, action });
       }
-      // ── Streaming response ────────────────────────────────────────────────
+      // ── Live message streaming (editMessageText pattern) ─────────────────
       /**
-       * Send a streaming draft to the user (Bot API 9.3+ sendMessageDraft).
-       * If not supported, falls back to editMessageText on a placeholder message.
+       * Send a placeholder message that will be progressively edited with
+       * streamed content. Returns the message_id for subsequent edits.
        */
-      async sendDraft(chatId, draftId, text) {
-        if (this.draftSupported === false)
-          return;
-        const truncated = text.length > 4e3 ? text.slice(0, 3997) + "..." : text;
+      async sendLiveMessage(chatId, initialText) {
         try {
-          const result = await this.apiCall("sendMessageDraft", {
+          const result = await this.apiCall("sendMessage", {
             chat_id: chatId,
-            draft_id: draftId,
-            text: truncated
+            text: initialText,
+            parse_mode: "HTML"
           });
-          if (result.ok !== false) {
-            if (this.draftSupported === null)
-              this.draftSupported = true;
-            return;
-          }
-          if (result.error_code === 404 || result.description?.includes("method not found")) {
-            this.draftSupported = false;
+          this.state.messagesSent++;
+          return result.result?.message_id ?? null;
+        } catch {
+          try {
+            const result = await this.apiCall("sendMessage", {
+              chat_id: chatId,
+              text: initialText
+            });
+            this.state.messagesSent++;
+            return result.result?.message_id ?? null;
+          } catch {
+            return null;
           }
+        }
+      }
+      /**
+       * Edit a live message with updated content. Used for progressive streaming.
+       * Handles rate limits and Telegram's "message is not modified" error silently.
+       */
+      async editLiveMessage(chatId, messageId, html) {
+        const truncated = html.length > 4e3 ? html.slice(0, 3950) + "\n\n<i>... (streaming)</i>" : html;
+        try {
+          const result = await this.apiCall("editMessageText", {
+            chat_id: chatId,
+            message_id: messageId,
+            text: truncated,
+            parse_mode: "HTML"
+          });
+          if (result.error_code === 400 && result.description?.includes("not modified"))
+            return;
         } catch {
-          this.draftSupported = false;
+          try {
+            const plain = html.replace(/<[^>]+>/g, "");
+            const truncPlain = plain.length > 4e3 ? plain.slice(0, 3950) + "\n\n... (streaming)" : plain;
+            await this.apiCall("editMessageText", {
+              chat_id: chatId,
+              message_id: messageId,
+              text: truncPlain
+            });
+          } catch {
+          }
         }
       }
       // ── Sub-agent spawning ────────────────────────────────────────────────
       /**
        * Handle an incoming Telegram message by spawning a sub-agent.
-       * Admin users get full tool access; public users get read-only + light memory.
+       * Tool access is determined by resolveToolContext() based on
+       * admin status AND chat type (DM vs group).
        */
       async handleMessageWithSubAgent(msg) {
         if (!this.agentConfig || !this.repoRoot) {
@@ -26346,36 +26789,56 @@ Keep responses concise for Telegram but don't withhold information from the admi
           return;
         }
         const isAdmin = this.isAdminUser(msg);
+        const toolContext = this.resolveToolContext(msg, isAdmin);
+        const isAdminDM = toolContext === "telegram-admin-dm";
         const existing = this.subAgents.get(msg.chatId);
         if (existing && !existing.aborted) {
           existing.runner.injectUserMessage(msg.text);
           renderTelegramSubAgentEvent(msg.username, "mid-conversation steering injected");
           return;
         }
-        const draftId = Date.now();
         const subAgent = {
           chatId: msg.chatId,
           username: msg.username,
           runner: null,
-          // set below
           typingInterval: null,
-          draftId,
+          liveMessageId: null,
           accumulated: "",
-          lastDraftMs: 0,
-          aborted: false
+          intermediateLines: [],
+          lastEditMs: 0,
+          aborted: false,
+          toolContext
         };
         this.subAgents.set(msg.chatId, subAgent);
         this.state.activeSubAgents = this.subAgents.size;
         subAgent.typingInterval = this.startTypingIndicator(msg.chatId);
-        renderTelegramSubAgentStart(msg.username, msg.text, isAdmin);
+        renderTelegramSubAgentStart(msg.username, msg.text, isAdminDM);
         try {
-          const result = await this.runSubAgent(msg, isAdmin, subAgent);
+          if (isAdminDM) {
+            const msgId = await this.sendLiveMessage(msg.chatId, "<i>\u23F3 Processing...</i>");
+            subAgent.liveMessageId = msgId;
+          }
+          let mediaContext = "";
+          if (msg.media) {
+            mediaContext = await this.processMedia(msg);
+          }
+          const result = await this.runSubAgent(msg, subAgent, mediaContext);
           if (subAgent.typingInterval) {
             clearInterval(subAgent.typingInterval);
             subAgent.typingInterval = null;
           }
+          if (result === "no_reply" || result === "") {
+            renderTelegramSubAgentEvent(msg.username, "discretion: skipped reply");
+            return;
+          }
           const finalText = result || "I couldn't generate a response. Please try again.";
-          await this.sendMessage(msg.chatId, finalText);
+          const finalHtml = convertMarkdownToTelegramHTML(finalText);
+          if (isAdminDM && subAgent.liveMessageId) {
+            const intermediateBlock = subAgent.intermediateLines.length > 0 ? subAgent.intermediateLines.join("\n") + "\n\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n" : "";
+            await this.editLiveMessage(msg.chatId, subAgent.liveMessageId, intermediateBlock + finalHtml);
+          } else {
+            await this.sendMessageHTML(msg.chatId, finalHtml, msg.chatType !== "private" ? msg.messageId : void 0);
+          }
           renderTelegramSubAgentComplete(msg.username, finalText);
         } catch (err) {
           if (subAgent.typingInterval) {
@@ -26384,73 +26847,118 @@ Keep responses concise for Telegram but don't withhold information from the admi
           }
           const errMsg = err instanceof Error ? err.message : String(err);
           renderTelegramSubAgentError(msg.username, errMsg);
-          await this.sendMessage(msg.chatId, "Sorry, I encountered an error processing your message. Please try again.").catch(() => {
-          });
+          if (isAdminDM && subAgent.liveMessageId) {
+            await this.editLiveMessage(msg.chatId, subAgent.liveMessageId, `\u274C Error: ${errMsg}`).catch(() => {
+            });
+          } else {
+            await this.sendMessage(msg.chatId, "Sorry, I encountered an error processing your message. Please try again.").catch(() => {
+            });
+          }
         } finally {
           this.subAgents.delete(msg.chatId);
           this.state.activeSubAgents = this.subAgents.size;
         }
       }
       /** Run a sub-agent for a Telegram message */
-      async runSubAgent(msg, isAdmin, subAgent) {
+      async runSubAgent(msg, subAgent, mediaContext = "") {
         const config = this.agentConfig;
         const repoRoot = this.repoRoot;
         const modelTier = getModelTier(config.model);
+        const ctx = subAgent.toolContext;
+        const isAdminDM = ctx === "telegram-admin-dm";
+        const isAdminGroup = ctx === "telegram-admin-group";
+        const isGroup = msg.chatType !== "private";
         const backend = new OllamaAgenticBackend(config.backendUrl, config.model, config.apiKey);
         const runner = new AgenticRunner(backend, {
-          maxTurns: isAdmin ? 30 : 8,
-          // Admin: full agent. Public: quick response
-          maxTokens: isAdmin ? 8192 : 2048,
-          // Admin: detailed. Public: concise
+          maxTurns: isAdminDM ? 30 : isAdminGroup ? 12 : 8,
+          maxTokens: isAdminDM ? 8192 : 2048,
           temperature: 0.3,
           requestTimeoutMs: config.timeoutMs,
-          taskTimeoutMs: isAdmin ? config.timeoutMs * 3 : config.timeoutMs,
+          taskTimeoutMs: isAdminDM ? config.timeoutMs * 3 : config.timeoutMs,
           compactionThreshold: modelTier === "small" ? 8e3 : 16e3,
           modelTier,
           streamEnabled: true
         });
         subAgent.runner = runner;
-        const tools = this.buildSubAgentTools(isAdmin, repoRoot);
+        const tools = this.buildSubAgentTools(ctx, repoRoot, msg.chatId);
         runner.registerTools(tools);
         runner.onEvent((event) => {
           if (subAgent.aborted)
             return;
           this.onSubAgentEvent?.(msg.chatId, msg.username, event);
-          if (event.type === "stream_token" && event.streamKind === "content" && event.content) {
-            subAgent.accumulated += event.content;
+          if (isAdminDM && subAgent.liveMessageId) {
+            if (event.type === "stream_token" && event.streamKind === "content" && event.content) {
+              subAgent.accumulated += event.content;
+            }
+            const intermediateLine = formatIntermediateState(event);
+            if (intermediateLine) {
+              subAgent.intermediateLines.push(intermediateLine);
+            }
             const now = Date.now();
-            if (now - subAgent.lastDraftMs > 1e3 && subAgent.accumulated.length > 20) {
-              subAgent.lastDraftMs = now;
-              this.sendDraft(msg.chatId, subAgent.draftId, subAgent.accumulated).catch(() => {
-              });
+            if (now - subAgent.lastEditMs > 1e3) {
+              const hasContent = subAgent.accumulated.length > 10 || subAgent.intermediateLines.length > 0;
+              if (hasContent) {
+                subAgent.lastEditMs = now;
+                const intermediateBlock = subAgent.intermediateLines.length > 0 ? subAgent.intermediateLines.join("\n") + "\n\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n" : "";
+                const contentPreview = subAgent.accumulated ? convertMarkdownToTelegramHTML(subAgent.accumulated) + "\n<i>\u258C</i>" : "<i>\u23F3 Working...</i>";
+                this.editLiveMessage(msg.chatId, subAgent.liveMessageId, intermediateBlock + contentPreview).catch(() => {
+                });
+              }
             }
           }
         });
-        const systemPrompt = isAdmin ? ADMIN_PROMPT : TELEGRAM_SAFETY_PROMPT;
-        const projectCtx = buildProjectContext(repoRoot);
-        const dynamicContext = isAdmin ? formatContextForPrompt(projectCtx, modelTier) : "";
-        const userPrompt = isAdmin ? `Telegram message from admin @${msg.username}:
-${msg.text}` : `${systemPrompt}
+        let systemPrompt;
+        if (isAdminDM) {
+          systemPrompt = ADMIN_DM_PROMPT;
+        } else if (isAdminGroup) {
+          systemPrompt = ADMIN_GROUP_PROMPT;
+        } else {
+          systemPrompt = TELEGRAM_SAFETY_PROMPT;
+        }
+        const discretionPrompt = isGroup ? `
+
+${GROUP_REPLY_DISCRETION_PROMPT}` : "";
+        const chatLabel = isGroup ? ` in group "${msg.chatTitle || "unknown"}"` : "";
+        let userPrompt;
+        if (isAdminDM) {
+          userPrompt = `Telegram message from admin @${msg.username}:
+${msg.text}`;
+        } else {
+          const toolHint = "You have access to isolated per-chat memory (memory_write, memory_read, memory_search) scoped to this conversation. You can remember facts about this user and retrieve them later. You also have web_search and web_fetch to look up information.";
+          userPrompt = `${systemPrompt}${discretionPrompt}
+
+${toolHint}
 
 ---
 
-Telegram message from @${msg.username}:
+Telegram message from @${msg.username}${chatLabel}:
 ${msg.text}
 
-Respond concisely and safely. Remember: you are talking to the general public.`;
-        const result = await runner.run(userPrompt, isAdmin ? `Working directory: ${repoRoot}
-Telegram admin: @${msg.username}` : `Telegram public chat. Respond concisely. Safety filter: ACTIVE.`);
+Respond concisely and safely.`;
+        }
+        if (mediaContext) {
+          userPrompt += `
+
+[Media attached \u2014 processed content below]
+${mediaContext}`;
+        }
+        const systemCtx = isAdminDM ? `Working directory: ${repoRoot}
+Telegram admin: @${msg.username}` : `Telegram ${isGroup ? "group" : "public"} chat. Respond concisely. Safety filter: ACTIVE.`;
+        const result = await runner.run(userPrompt, systemCtx);
         return result.summary || subAgent.accumulated || "";
       }
-      /** Build tool set based on access level */
-      buildSubAgentTools(isAdmin, repoRoot) {
+      /**
+       * Build tool set based on tool context, filtered through the policy system.
+       * All possible tools are instantiated, then applyToolPolicy filters them.
+       */
+      buildSubAgentTools(context, repoRoot, chatId) {
         const taskComplete = {
           name: "task_complete",
-          description: "Signal that your response is ready to send to the Telegram user.",
+          description: "Signal that your response is ready to send to the Telegram user. Use summary 'no_reply' to silently skip responding.",
           parameters: {
             type: "object",
             properties: {
-              summary: { type: "string", description: "The response to send to the Telegram user" }
+              summary: { type: "string", description: "The response to send to the Telegram user, or 'no_reply' to skip" }
             },
             required: ["summary"]
           },
@@ -26458,57 +26966,195 @@ Telegram admin: @${msg.username}` : `Telegram public chat. Respond concisely. Sa
             return { success: true, output: args["summary"] || "Done." };
           }
         };
-        if (isAdmin) {
-          const tools2 = [
-            new FileReadTool(repoRoot),
-            new GrepSearchTool(repoRoot),
-            new GlobFindTool(repoRoot),
-            new ListDirectoryTool(repoRoot),
-            new MemoryReadTool(repoRoot),
-            new MemoryWriteTool(repoRoot),
-            new MemorySearchTool(repoRoot),
-            new WebFetchTool(),
-            new WebSearchTool()
-          ];
-          return [...tools2.map(adaptTool4), taskComplete];
-        }
-        const tools = [
+        const allTools = [
+          // File tools
+          new FileReadTool(repoRoot),
+          new GrepSearchTool(repoRoot),
+          new GlobFindTool(repoRoot),
+          new ListDirectoryTool(repoRoot),
+          // Memory tools
           new MemoryReadTool(repoRoot),
-          // Can read public-facing memory
+          new MemoryWriteTool(repoRoot),
           new MemorySearchTool(repoRoot),
-          // Can search for relevant info
+          // Web tools
+          new WebFetchTool(),
           new WebSearchTool(),
-          // Can search the web to answer questions
-          new WebFetchTool()
-          // Can fetch public web pages
+          new WebCrawlTool(repoRoot),
+          // Vision/OCR tools
+          new ImageReadTool(repoRoot),
+          new OCRTool(repoRoot),
+          new VisionTool(repoRoot),
+          new OcrPdfTool(repoRoot),
+          new PdfToTextTool(repoRoot),
+          // Transcription tools
+          new TranscribeFileTool(repoRoot),
+          new TranscribeUrlTool(repoRoot)
         ];
-        return [...tools.map(adaptTool4), taskComplete];
+        let adaptedTools = allTools.map(adaptTool4);
+        adaptedTools = applyToolPolicy(adaptedTools, context, this.toolPolicyConfig);
+        if (context !== "telegram-admin-dm") {
+          const memWriteIdx = adaptedTools.findIndex((t) => t.name === "memory_write");
+          if (memWriteIdx >= 0) {
+            const original = adaptedTools[memWriteIdx];
+            const scopedChatId = chatId ?? 0;
+            adaptedTools[memWriteIdx] = {
+              ...original,
+              description: "Store a fact in this chat's isolated memory. Topics are automatically scoped to this conversation.",
+              async execute(args) {
+                const userTopic = args["topic"] || "general";
+                args["topic"] = `telegram-${scopedChatId}-${userTopic}`;
+                return original.execute(args);
+              }
+            };
+          }
+        }
+        return [...adaptedTools, taskComplete];
       }
-      /** Check if a message is from the admin user */
+      /** Check if a message is from the admin user (uses fromUserId, NOT chatId) */
       isAdminUser(msg) {
         if (!this.adminUserId)
           return false;
-        const fromId = String(msg.chatId);
+        const fromId = String(msg.fromUserId);
         return fromId === this.adminUserId || msg.username === this.adminUserId;
       }
+      /**
+       * Resolve the tool context for a message based on admin status and chat type.
+       * Admin in private DM → telegram-admin-dm (full tools)
+       * Admin in group/supergroup → telegram-admin-group (restricted!)
+       * Anyone else → telegram-public (minimal tools)
+       */
+      resolveToolContext(msg, isAdmin) {
+        if (!isAdmin)
+          return "telegram-public";
+        if (msg.chatType === "private")
+          return "telegram-admin-dm";
+        return "telegram-admin-group";
+      }
+      // ── Media handling ──────────────────────────────────────────────────
+      /**
+       * Download a Telegram file by file_id and save to the media cache.
+       * Returns the local file path.
+       */
+      async downloadTelegramFile(fileId, extension) {
+        try {
+          const fileInfo = await this.apiCall("getFile", { file_id: fileId });
+          const filePath = fileInfo.result?.file_path;
+          if (!filePath)
+            return null;
+          const downloadUrl = `https://api.telegram.org/file/bot${this.botToken}/${filePath}`;
+          const res = await fetch(downloadUrl);
+          if (!res.ok)
+            return null;
+          const buffer = Buffer.from(await res.arrayBuffer());
+          const fileName = `${Date.now()}-${fileId.slice(0, 8)}${extension}`;
+          const localPath = join39(this.mediaCacheDir, fileName);
+          await writeFileAsync(localPath, buffer);
+          return localPath;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Process media from a Telegram message.
+       * Downloads the file, runs it through the appropriate pipeline,
+       * caches it, and returns a text description for the agent.
+       */
+      async processMedia(msg) {
+        if (!msg.media)
+          return "";
+        const { type, fileId, fileUniqueId, mimeType, caption } = msg.media;
+        let ext = ".bin";
+        if (type === "photo")
+          ext = ".jpg";
+        else if (type === "audio" || type === "voice")
+          ext = ".ogg";
+        else if (type === "video" || type === "video_note")
+          ext = ".mp4";
+        else if (msg.media.fileName) {
+          const dotIdx = msg.media.fileName.lastIndexOf(".");
+          if (dotIdx >= 0)
+            ext = msg.media.fileName.slice(dotIdx);
+        }
+        const localPath = await this.downloadTelegramFile(fileId, ext);
+        if (!localPath)
+          return `[Media: ${type} \u2014 failed to download]`;
+        const cacheEntry = {
+          localPath,
+          fileId,
+          chatId: msg.chatId,
+          username: msg.username,
+          mediaType: type,
+          mimeType,
+          cachedAt: Date.now()
+        };
+        this.mediaCache.set(fileUniqueId, cacheEntry);
+        if (!this.mediaMetadata.has(msg.chatId)) {
+          this.mediaMetadata.set(msg.chatId, []);
+        }
+        this.mediaMetadata.get(msg.chatId).push({
+          timestamp: Date.now(),
+          type,
+          mimeType,
+          caption,
+          username: msg.username
+        });
+        let description = `[${type}${caption ? `: ${caption}` : ""}]`;
+        if (type === "photo") {
+          description = `[Photo received and saved to ${localPath}${caption ? ` \u2014 caption: "${caption}"` : ""}. You can use image_read or vision tools to analyze it if available.]`;
+        }
+        if (type === "audio" || type === "voice") {
+          description = `[Audio/voice message received and saved to ${localPath}${caption ? ` \u2014 caption: "${caption}"` : ""}. You can use transcribe_file to transcribe it if available.]`;
+        }
+        if (type === "video" || type === "video_note") {
+          description = `[Video received and saved to ${localPath}${caption ? ` \u2014 caption: "${caption}"` : ""}.]`;
+        }
+        if (type === "document") {
+          description = `[Document received: ${msg.media.fileName || "unnamed"}${mimeType ? ` (${mimeType})` : ""}, saved to ${localPath}${caption ? ` \u2014 caption: "${caption}"` : ""}.]`;
+        }
+        cacheEntry.extractedContent = description;
+        return description;
+      }
+      /** Clean up expired media cache entries (older than 30 minutes) */
+      cleanupMediaCache() {
+        const now = Date.now();
+        for (const [key, entry] of this.mediaCache) {
+          if (now - entry.cachedAt > MEDIA_CACHE_TTL_MS) {
+            try {
+              unlinkSync6(entry.localPath);
+            } catch {
+            }
+            this.mediaCache.delete(key);
+          }
+        }
+      }
       // ── Message sending ───────────────────────────────────────────────────
-      /** Send a response back to a Telegram chat */
+      /** Send a response back to a Telegram chat (Markdown → HTML conversion) */
       async sendMessage(chatId, text) {
-        const truncated = text.length > 4e3 ? text.slice(0, 3950) + "\n\n... (truncated)" : text;
+        const html = convertMarkdownToTelegramHTML(text);
+        return this.sendMessageHTML(chatId, html);
+      }
+      /** Send an HTML-formatted message to a Telegram chat */
+      async sendMessageHTML(chatId, html, replyToMessageId) {
+        const truncated = html.length > 4e3 ? html.slice(0, 3950) + "\n\n<i>... (truncated)</i>" : html;
+        const body = {
+          chat_id: chatId,
+          text: truncated,
+          parse_mode: "HTML"
+        };
+        if (replyToMessageId)
+          body["reply_to_message_id"] = replyToMessageId;
         try {
-          const result = await this.apiCall("sendMessage", {
-            chat_id: chatId,
-            text: truncated,
-            parse_mode: "Markdown"
-          });
+          const result = await this.apiCall("sendMessage", body);
           this.state.messagesSent++;
           return result.result?.message_id ?? null;
         } catch {
+          const plain = html.replace(/<[^>]+>/g, "");
+          const truncPlain = plain.length > 4e3 ? plain.slice(0, 3950) + "\n\n... (truncated)" : plain;
+          const fallbackBody = { chat_id: chatId, text: truncPlain };
+          if (replyToMessageId)
+            fallbackBody["reply_to_message_id"] = replyToMessageId;
           try {
-            const result = await this.apiCall("sendMessage", {
-              chat_id: chatId,
-              text: truncated
-            });
+            const result = await this.apiCall("sendMessage", fallbackBody);
             this.state.messagesSent++;
             return result.result?.message_id ?? null;
           } catch (err) {
@@ -26530,29 +27176,104 @@ Telegram admin: @${msg.username}` : `Telegram public chat. Respond concisely. Sa
             if (result.ok && Array.isArray(result.result)) {
               for (const update of result.result) {
                 this.lastUpdateId = update.update_id;
-                if (update.message?.text) {
-                  const fromId = String(update.message.from?.id ?? "");
-                  const fromUser = update.message.from?.username ?? "";
-                  const isAdmin = this.adminUserId ? fromId === this.adminUserId || fromUser === this.adminUserId : false;
-                  if (this.adminUserId && !this.agentConfig) {
-                    if (!isAdmin)
-                      continue;
-                  }
-                  this.state.messagesReceived++;
-                  const msg = {
-                    chatId: update.message.chat.id,
-                    text: update.message.text,
-                    username: fromUser || "unknown",
-                    firstName: update.message.from?.first_name,
-                    messageId: update.message.message_id
+                const message = update.message;
+                if (!message)
+                  continue;
+                const fromId = message.from?.id ?? 0;
+                const fromUser = message.from?.username ?? "";
+                const chatType = message.chat?.type ?? "private";
+                const chatTitle = message.chat?.title;
+                const isAdmin = this.adminUserId ? String(fromId) === this.adminUserId || fromUser === this.adminUserId : false;
+                if (this.adminUserId && !this.agentConfig) {
+                  if (!isAdmin)
+                    continue;
+                }
+                let media;
+                if (message.photo && message.photo.length > 0) {
+                  const photo = message.photo[message.photo.length - 1];
+                  media = {
+                    type: "photo",
+                    fileId: photo.file_id,
+                    fileUniqueId: photo.file_unique_id,
+                    fileSize: photo.file_size,
+                    caption: message.caption
                   };
-                  if (this.agentConfig && this.repoRoot) {
-                    this.handleMessageWithSubAgent(msg).catch((err) => {
-                      renderWarning(`Telegram sub-agent error: ${err instanceof Error ? err.message : String(err)}`);
-                    });
-                  } else {
-                    this.onMessage(msg);
-                  }
+                } else if (message.audio) {
+                  media = {
+                    type: "audio",
+                    fileId: message.audio.file_id,
+                    fileUniqueId: message.audio.file_unique_id,
+                    mimeType: message.audio.mime_type,
+                    fileName: message.audio.file_name,
+                    fileSize: message.audio.file_size,
+                    duration: message.audio.duration,
+                    caption: message.caption
+                  };
+                } else if (message.voice) {
+                  media = {
+                    type: "voice",
+                    fileId: message.voice.file_id,
+                    fileUniqueId: message.voice.file_unique_id,
+                    mimeType: message.voice.mime_type,
+                    fileSize: message.voice.file_size,
+                    duration: message.voice.duration,
+                    caption: message.caption
+                  };
+                } else if (message.video) {
+                  media = {
+                    type: "video",
+                    fileId: message.video.file_id,
+                    fileUniqueId: message.video.file_unique_id,
+                    mimeType: message.video.mime_type,
+                    fileName: message.video.file_name,
+                    fileSize: message.video.file_size,
+                    duration: message.video.duration,
+                    caption: message.caption
+                  };
+                } else if (message.video_note) {
+                  media = {
+                    type: "video_note",
+                    fileId: message.video_note.file_id,
+                    fileUniqueId: message.video_note.file_unique_id,
+                    fileSize: message.video_note.file_size,
+                    duration: message.video_note.duration,
+                    caption: message.caption
+                  };
+                } else if (message.document) {
+                  media = {
+                    type: "document",
+                    fileId: message.document.file_id,
+                    fileUniqueId: message.document.file_unique_id,
+                    mimeType: message.document.mime_type,
+                    fileName: message.document.file_name,
+                    fileSize: message.document.file_size,
+                    caption: message.caption
+                  };
+                }
+                const hasText = !!message.text;
+                const hasCaption = !!message.caption;
+                const hasMedia = !!media;
+                if (!hasText && !hasMedia)
+                  continue;
+                this.state.messagesReceived++;
+                const msg = {
+                  chatId: message.chat.id,
+                  text: message.text || message.caption || "",
+                  username: fromUser || "unknown",
+                  firstName: message.from?.first_name,
+                  messageId: message.message_id,
+                  fromUserId: fromId,
+                  chatType,
+                  chatTitle,
+                  media,
+                  replyToMessageId: message.reply_to_message?.message_id
+                };
+                if (this.agentConfig && this.repoRoot) {
+                  this.handleMessageWithSubAgent(msg).catch((err) => {
+                    renderWarning(`Telegram sub-agent error: ${err instanceof Error ? err.message : String(err)}`);
+                  });
+                } else {
+                  this.onMessage(msg);
                 }
               }
             }
@@ -27174,6 +27895,20 @@ var init_status_bar = __esm({
         if (this.active)
           this.renderFooterPreserveCursor();
       }
+      /** Current emotional state — emoji + label from EmotionEngine */
+      _emotion = null;
+      /** Update emotional state indicator */
+      setEmotion(emoji, label) {
+        this._emotion = { emoji, label };
+        if (this.active)
+          this.renderFooterPreserveCursor();
+      }
+      /** Clear emotional state indicator */
+      clearEmotion() {
+        this._emotion = null;
+        if (this.active)
+          this.renderFooterPreserveCursor();
+      }
       /** Model capabilities — shown as emoji indicators on the status bar */
       _caps = {
         vision: false,
@@ -27388,6 +28123,10 @@ var init_status_bar = __esm({
           const capStr = this._snr.capacityWarning ? c2.red(" !CAP") : "";
           snrLabel = pipe + pastel2(183, "SNR: ") + snrColor(c2.bold(`${snrPct}%`)) + c2.dim(` d'${dPrimeStr}`) + capStr;
         }
+        let emotionLabel = "";
+        if (this._emotion) {
+          emotionLabel = pipe + this._emotion.emoji + " " + pastel2(183, this._emotion.label);
+        }
         let speedLabel = "";
         if (this._speedTracker.hasData) {
           const ratio = this._speedTracker.getSpeedRatio();
@@ -27411,7 +28150,7 @@ var init_status_bar = __esm({
         if (this._caps.thinking)
           capParts.push("\u{1F9E0}");
         const capsLabel = capParts.length > 0 ? pipe + pastel2(183, capParts.join(" ")) : "";
-        return ` ${tokInLabel}${pipe}${tokOutLabel}${pipe}${ctxLabel}${snrLabel}${speedLabel}${costLabel}${capsLabel}${recordingLabel}`;
+        return ` ${tokInLabel}${pipe}${tokOutLabel}${pipe}${ctxLabel}${snrLabel}${emotionLabel}${speedLabel}${costLabel}${capsLabel}${recordingLabel}`;
       }
       // -------------------------------------------------------------------------
       // Private
@@ -27690,11 +28429,11 @@ var init_status_bar = __esm({
 import * as readline2 from "node:readline";
 import { Writable } from "node:stream";
 import { cwd } from "node:process";
-import { resolve as resolve24, join as join39, dirname as dirname12, extname as extname9 } from "node:path";
+import { resolve as resolve25, join as join40, dirname as dirname12, extname as extname9 } from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
-import { readFileSync as readFileSync22, rmSync as rmSync2, readdirSync as readdirSync13 } from "node:fs";
-import { existsSync as existsSync29 } from "node:fs";
+import { readFileSync as readFileSync22, rmSync as rmSync2, readdirSync as readdirSync14 } from "node:fs";
+import { existsSync as existsSync30 } from "node:fs";
 function formatTimeAgo(date) {
   const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
   if (seconds < 60)
@@ -27713,12 +28452,12 @@ function getVersion() {
     const require2 = createRequire2(import.meta.url);
     const thisDir = dirname12(fileURLToPath9(import.meta.url));
     const candidates = [
-      join39(thisDir, "..", "package.json"),
-      join39(thisDir, "..", "..", "package.json"),
-      join39(thisDir, "..", "..", "..", "package.json")
+      join40(thisDir, "..", "package.json"),
+      join40(thisDir, "..", "..", "package.json"),
+      join40(thisDir, "..", "..", "..", "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync29(pkgPath)) {
+      if (existsSync30(pkgPath)) {
         const pkg = require2(pkgPath);
         if (pkg.name === "open-agents-ai" || pkg.name === "@open-agents/cli") {
           return pkg.version ?? "0.0.0";
@@ -27912,15 +28651,15 @@ Use task_status("${taskId}") or task_output("${taskId}") to check progress.`
 function gatherMemorySnippets(root) {
   const snippets = [];
   const dirs = [
-    join39(root, ".oa", "memory"),
-    join39(root, ".open-agents", "memory")
+    join40(root, ".oa", "memory"),
+    join40(root, ".open-agents", "memory")
   ];
   for (const dir of dirs) {
-    if (!existsSync29(dir))
+    if (!existsSync30(dir))
       continue;
     try {
-      for (const f of readdirSync13(dir).filter((f2) => f2.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync22(join39(dir, f), "utf-8"));
+      for (const f of readdirSync14(dir).filter((f2) => f2.endsWith(".json"))) {
+        const data = JSON.parse(readFileSync22(join40(dir, f), "utf-8"));
         for (const val of Object.values(data)) {
           const v = typeof val === "object" && val !== null && "value" in val ? String(val.value) : String(val);
           if (v.length > 10)
@@ -27989,7 +28728,7 @@ function formatDMNToolArgs(toolName, args) {
       return "";
   }
 }
-function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction) {
+function startTask(task, config, repoRoot, voice, stream, taskStores, bruteForce, statusBar, sudoCallback, costTracker, onComplete, taskType, contextWindowSize, modelCaps, personality, deepContext, onCompaction, emotionEngine) {
   const voiceStyleMap = {
     concise: 1,
     balanced: 3,
@@ -28102,6 +28841,7 @@ ${entry.fullContent}`
     }
   };
   runner.onEvent((event) => {
+    emotionEngine?.appraise(event);
     switch (event.type) {
       case "tool_call":
         toolSequence.push({
@@ -28239,7 +28979,11 @@ ${entry.fullContent}`
     }
   });
   const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const promise = runner.run(task, `Working directory: ${repoRoot}`).then((result) => {
+  const emotionContext = emotionEngine?.getEmotionForPrompt() ?? "";
+  const systemContext = emotionContext ? `Working directory: ${repoRoot}
+
+${emotionContext}` : `Working directory: ${repoRoot}`;
+  const promise = runner.run(task, systemContext).then((result) => {
     const tokens = { total: result.totalTokens, estimated: result.estimatedTokens };
     contentWrite(() => {
       if (result.completed) {
@@ -28320,7 +29064,7 @@ ${entry.fullContent}`
   } };
 }
 async function startInteractive(config, repoPath) {
-  const repoRoot = resolve24(repoPath ?? cwd());
+  const repoRoot = resolve25(repoPath ?? cwd());
   const resumeFlag = process.env.__OA_RESUMED ?? "";
   const isResumed = resumeFlag !== "";
   const hasTaskToResume = resumeFlag === "1";
@@ -28474,14 +29218,14 @@ async function startInteractive(config, repoPath) {
       renderInfo(msg);
       statusBar.endContentWrite();
     }
-  }, () => new Promise((resolve27) => {
+  }, () => new Promise((resolve28) => {
     depSudoPromptPending = true;
     depSudoResolver = (pw) => {
       depSudoPromptPending = false;
       depSudoResolver = null;
       if (pw)
         sessionSudoPassword = pw;
-      resolve27(pw);
+      resolve28(pw);
     };
     if (statusBar?.isActive) {
       statusBar.beginContentWrite();
@@ -28509,6 +29253,15 @@ async function startInteractive(config, repoPath) {
   let blessEngine = null;
   let dmnEngine = null;
   const snrEngine = new SNREngine(config, repoRoot);
+  const emotionEngine = new EmotionEngine({
+    backendUrl: config.backendUrl,
+    model: config.model,
+    apiKey: config.apiKey,
+    onEmotionUpdate: (state) => {
+      statusBar.setEmotion(state.emoji, state.label);
+    }
+    // Admin outreach wired after telegram bridge is initialized (see telegramStart)
+  });
   let pendingSNREval = null;
   function scheduleAgentSNREval(taskPrompt) {
     if (pendingSNREval)
@@ -28960,6 +29713,16 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
           writeContent(() => renderTelegramSubAgentEvent(username, event.content));
         }
       });
+      if (adminId) {
+        const bridge = telegramBridge;
+        const adminChatId = parseInt(adminId, 10);
+        if (!isNaN(adminChatId)) {
+          emotionEngine.setAdminOutreach((message) => {
+            bridge.sendMessage(adminChatId, message).catch(() => {
+            });
+          });
+        }
+      }
       await telegramBridge.start();
       writeContent(() => renderTelegramStart(telegramBridge.botUsername, adminId));
       showPrompt();
@@ -29115,8 +29878,8 @@ Respond concisely and safely. Remember: you are talking to the general public.`;
       return true;
     },
     destroyProject() {
-      const oaPath = join39(repoRoot, OA_DIR);
-      if (existsSync29(oaPath)) {
+      const oaPath = join40(repoRoot, OA_DIR);
+      if (existsSync30(oaPath)) {
         try {
           rmSync2(oaPath, { recursive: true, force: true });
           writeContent(() => renderInfo(`Removed ${OA_DIR}/ directory.`));
@@ -29375,7 +30138,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
             toolPatternStore: toolPatternStore ?? void 0
           }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary) => {
             lastCompletedSummary = summary;
-          }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback());
+          }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine);
           activeTask = task;
           showPrompt();
           await task.promise;
@@ -29390,12 +30153,12 @@ Execute this skill now. Follow the behavioral guidance above.`;
       }
     }
     const cleanPath = input.replace(/^['"]|['"]$/g, "").trim();
-    const isImage = isImagePath(cleanPath) && existsSync29(resolve24(repoRoot, cleanPath));
-    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync29(resolve24(repoRoot, cleanPath));
+    const isImage = isImagePath(cleanPath) && existsSync30(resolve25(repoRoot, cleanPath));
+    const isMedia = !isImage && isTranscribablePath(cleanPath) && existsSync30(resolve25(repoRoot, cleanPath));
     if (activeTask) {
       if (isImage) {
         try {
-          const imgPath = resolve24(repoRoot, cleanPath);
+          const imgPath = resolve25(repoRoot, cleanPath);
           const imgBuffer = readFileSync22(imgPath);
           const base64 = imgBuffer.toString("base64");
           const ext = extname9(cleanPath).toLowerCase();
@@ -29409,7 +30172,7 @@ Execute this skill now. Follow the behavioral guidance above.`;
       } else if (isMedia) {
         writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
         const engine = getListenEngine();
-        const result = await engine.transcribeFile(resolve24(repoRoot, cleanPath), repoRoot);
+        const result = await engine.transcribeFile(resolve25(repoRoot, cleanPath), repoRoot);
         if (result) {
           const transcript = `[Transcription of ${cleanPath}]
 ${result.text}`;
@@ -29442,7 +30205,7 @@ ${result.text}`;
     if (isMedia && fullInput === input) {
       writeContent(() => renderInfo(`Transcribing: ${cleanPath}...`));
       const engine = getListenEngine();
-      const result = await engine.transcribeFile(resolve24(repoRoot, cleanPath), repoRoot);
+      const result = await engine.transcribeFile(resolve25(repoRoot, cleanPath), repoRoot);
       if (result) {
         fullInput = `The user has provided an audio/video file: ${cleanPath}.
 
@@ -29495,7 +30258,7 @@ NEW TASK: ${fullInput}`;
         toolPatternStore: toolPatternStore ?? void 0
       }, bruteForceEnabled, statusBar, handleSudoRequest, costTracker, (summary) => {
         lastCompletedSummary = summary;
-      }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback());
+      }, currentTaskType, resolvedContextWindowSize, resolvedCaps, currentStyle, deepContextEnabled, compactionSNRCallback(), emotionEngine);
       activeTask = task;
       showPrompt();
       await task.promise;
@@ -29660,7 +30423,7 @@ ${c2.dim("(Use /quit to exit)")}
   });
 }
 async function runWithTUI(task, config, repoPath) {
-  const repoRoot = resolve24(repoPath ?? cwd());
+  const repoRoot = resolve25(repoPath ?? cwd());
   const needsSetup = isFirstRun() || !await isModelAvailable(config);
   if (needsSetup && config.backendType === "ollama") {
     const setupModel = await runSetupWizard(config);
@@ -29732,6 +30495,7 @@ var init_interactive = __esm({
     init_bless_engine();
     init_dmn_engine();
     init_snr_engine();
+    init_emotion_engine();
     init_telegram_bridge();
     init_status_bar();
     init_dist6();
@@ -29770,7 +30534,7 @@ import { glob } from "glob";
 import ignore from "ignore";
 import { readFile as readFile14, stat as stat4 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join as join40, relative as relative3, extname as extname10, basename as basename15 } from "node:path";
+import { join as join41, relative as relative3, extname as extname10, basename as basename15 } from "node:path";
 var DEFAULT_EXCLUDE, LANGUAGE_MAP, CodebaseIndexer;
 var init_codebase_indexer = __esm({
   "packages/indexer/dist/codebase-indexer.js"() {
@@ -29814,7 +30578,7 @@ var init_codebase_indexer = __esm({
         const ig = ignore.default();
         if (this.config.respectGitignore) {
           try {
-            const gitignoreContent = await readFile14(join40(this.config.rootDir, ".gitignore"), "utf-8");
+            const gitignoreContent = await readFile14(join41(this.config.rootDir, ".gitignore"), "utf-8");
             ig.add(gitignoreContent);
           } catch {
           }
@@ -29829,7 +30593,7 @@ var init_codebase_indexer = __esm({
         for (const relativePath of files) {
           if (ig.ignores(relativePath))
             continue;
-          const fullPath = join40(this.config.rootDir, relativePath);
+          const fullPath = join41(this.config.rootDir, relativePath);
           try {
             const fileStat = await stat4(fullPath);
             if (fileStat.size > this.config.maxFileSize)
@@ -29875,7 +30639,7 @@ var init_codebase_indexer = __esm({
               if (!child) {
                 child = {
                   name: part,
-                  path: join40(current.path, part),
+                  path: join41(current.path, part),
                   type: "directory",
                   children: []
                 };
@@ -29957,18 +30721,18 @@ var index_repo_exports = {};
 __export(index_repo_exports, {
   indexRepoCommand: () => indexRepoCommand
 });
-import { resolve as resolve25 } from "node:path";
-import { existsSync as existsSync30, statSync as statSync10 } from "node:fs";
+import { resolve as resolve26 } from "node:path";
+import { existsSync as existsSync31, statSync as statSync11 } from "node:fs";
 import { cwd as cwd2 } from "node:process";
 async function indexRepoCommand(opts, _config) {
-  const repoRoot = resolve25(opts.repoPath ?? cwd2());
+  const repoRoot = resolve26(opts.repoPath ?? cwd2());
   printHeader("Index Repository");
   printInfo(`Indexing: ${repoRoot}`);
-  if (!existsSync30(repoRoot)) {
+  if (!existsSync31(repoRoot)) {
     printError(`Path does not exist: ${repoRoot}`);
     process.exit(1);
   }
-  const stat5 = statSync10(repoRoot);
+  const stat5 = statSync11(repoRoot);
   if (!stat5.isDirectory()) {
     printError(`Path is not a directory: ${repoRoot}`);
     process.exit(1);
@@ -30216,7 +30980,7 @@ var config_exports = {};
 __export(config_exports, {
   configCommand: () => configCommand
 });
-import { join as join41, resolve as resolve26 } from "node:path";
+import { join as join42, resolve as resolve27 } from "node:path";
 import { homedir as homedir13 } from "node:os";
 import { cwd as cwd3 } from "node:process";
 function redactIfSensitive(key, value) {
@@ -30243,7 +31007,7 @@ async function configCommand(opts, config) {
   return handleShow(opts, config);
 }
 function handleShow(opts, config) {
-  const repoRoot = resolve26(opts.repoPath ?? cwd3());
+  const repoRoot = resolve27(opts.repoPath ?? cwd3());
   printHeader("Configuration");
   printSection("Active Settings (merged)");
   printKeyValue("backendUrl", config.backendUrl, 2);
@@ -30275,7 +31039,7 @@ function handleShow(opts, config) {
     }
   }
   printSection("Config File");
-  printInfo(`~/.open-agents/config.json (${join41(homedir13(), ".open-agents", "config.json")})`);
+  printInfo(`~/.open-agents/config.json (${join42(homedir13(), ".open-agents", "config.json")})`);
   printSection("Priority Chain");
   printInfo("  1. CLI flags (--model, --backend-url, etc.)");
   printInfo("  2. Project .oa/settings.json (--local)");
@@ -30308,13 +31072,13 @@ function handleSet(opts, _config) {
     process.exit(1);
   }
   if (opts.local) {
-    const repoRoot = resolve26(opts.repoPath ?? cwd3());
+    const repoRoot = resolve27(opts.repoPath ?? cwd3());
     try {
       initOaDirectory(repoRoot);
       const coerced = coerceForSettings(key, value);
       saveProjectSettings(repoRoot, { [key]: coerced });
       printSuccess(`Project override set: ${key} = ${redactIfSensitive(key, value)}`);
-      printInfo(`Saved to ${join41(repoRoot, ".oa", "settings.json")}`);
+      printInfo(`Saved to ${join42(repoRoot, ".oa", "settings.json")}`);
       printInfo("This override applies only when running in this workspace.");
     } catch (err) {
       printError(`Failed to save: ${err instanceof Error ? err.message : String(err)}`);
@@ -30467,7 +31231,7 @@ async function serveVllm(opts, config) {
   await runVllmServer(args, opts.verbose ?? false);
 }
 async function runVllmServer(args, verbose) {
-  return new Promise((resolve27, reject) => {
+  return new Promise((resolve28, reject) => {
     const child = spawn11("python", args, {
       stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
       env: { ...process.env }
@@ -30502,10 +31266,10 @@ async function runVllmServer(args, verbose) {
     child.once("exit", (code, signal) => {
       if (signal) {
         printInfo(`vLLM server stopped by signal ${signal}`);
-        resolve27();
+        resolve28();
       } else if (code === 0) {
         printSuccess("vLLM server exited cleanly");
-        resolve27();
+        resolve28();
       } else {
         printError(`vLLM server exited with code ${code}`);
         reject(new Error(`vLLM exited with code ${code}`));
@@ -30533,8 +31297,8 @@ __export(eval_exports, {
   evalCommand: () => evalCommand
 });
 import { tmpdir as tmpdir7 } from "node:os";
-import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join42 } from "node:path";
+import { mkdirSync as mkdirSync15, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join43 } from "node:path";
 async function evalCommand(opts, config) {
   const suiteName = opts.suite ?? "basic";
   const suite = SUITES[suiteName];
@@ -30655,9 +31419,9 @@ async function evalCommand(opts, config) {
   process.exit(failed > 0 ? 1 : 0);
 }
 function createTempEvalRepo() {
-  const dir = join42(tmpdir7(), `open-agents-eval-${Date.now()}`);
-  mkdirSync14(dir, { recursive: true });
-  writeFileSync13(join42(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
+  const dir = join43(tmpdir7(), `open-agents-eval-${Date.now()}`);
+  mkdirSync15(dir, { recursive: true });
+  writeFileSync13(join43(dir, "package.json"), JSON.stringify({ name: "eval-repo", version: "0.0.0" }, null, 2) + "\n", "utf8");
   return dir;
 }
 var BASIC_SUITE, FULL_SUITE, SUITES;
@@ -30717,7 +31481,7 @@ init_updater();
 import { parseArgs as nodeParseArgs2 } from "node:util";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath10 } from "node:url";
-import { dirname as dirname13, join as join43 } from "node:path";
+import { dirname as dirname13, join as join44 } from "node:path";
 
 // packages/cli/dist/cli.js
 import { createInterface } from "node:readline";
@@ -30824,7 +31588,7 @@ init_output();
 function getVersion2() {
   try {
     const require2 = createRequire3(import.meta.url);
-    const pkgPath = join43(dirname13(fileURLToPath10(import.meta.url)), "..", "package.json");
+    const pkgPath = join44(dirname13(fileURLToPath10(import.meta.url)), "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {