blun-king-cli 9.1.53 → 9.1.58

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.53
+  npm install -g blun-king-cli@9.1.57
 
 Start
 -----
@@ -20,10 +20,30 @@ Start
 Beide Startbefehle verwenden dieselbe Version, dasselbe Konto, dasselbe Modell
 und dieselben Befehle.
 
+Zuverlässiger King-Start
+-----------------------
+Der Windows-Hilfsprozess für private Pfade übernimmt TEMP und TMP aus der
+Benutzersitzung. Dadurch arbeitet die ACL-Prüfung auch unter einem normalen
+Benutzerkonto. Bei einem Fehler wird die tatsächliche Ursache des
+Unterprozesses angezeigt.
+
+Ein laufender Telegram-Prozess blockiert Aktualisierungen nicht mehr.
+Unveränderte Plugin-Dateien werden wiederverwendet; geänderte Dateien werden in
+einem inhaltsadressierten Verzeichnis daneben installiert. Der neue Prozess
+verwendet den neuen Pfad, während der bisherige Prozess seinen geladenen Stand
+geordnet beenden kann.
+
 Beim Fortsetzen mit --continue oder --session wird der Arbeitsbereich der
 bestehenden Sitzung direkt verwendet. Die Ordnerauswahl bleibt neuen Starts
 vorbehalten und kann eine Fortsetzung daher nicht mehr vorzeitig beenden.
 
+Schnellstart
+------------
+Beim Starten oder Fortsetzen einer Sitzung werden die Skill-Verzeichnisse
+parallel geprüft und eingelesen. Die Skills werden weiterhin in der
+ursprünglichen, festen Reihenfolge registriert; Priorität und Verhalten bei
+doppelten Namen bleiben unverändert.
+
 Zug-Wächter
 -----------
 Läuft ein Zug 20 Minuten ohne neues Werkzeugergebnis, meldet die Konsole den
@@ -63,8 +83,16 @@ Der erste Werkzeugaufruf muss den sichtbaren Plan setzen. Ausgehende Aktionen
 werden zusätzlich pro Werkzeugaufruf geprüft und bei fehlender Kanal- oder
 Zugangsfreigabe angehalten.
 
+/chancenradar <Ziel> startet einen eigenen Modus zur Chancensuche. Der Agent
+durchsucht aktuelle öffentliche Quellen, Foren und Communitys nach echten
+Problemen und bestehenden Lösungsansätzen, trennt Belege von Schlussfolgerungen,
+bewertet Chancen nach Wirkung, Passung, Aufwand und Verlässlichkeit und setzt den
+besten sicheren lokalen nächsten Schritt um. Der sichtbare Aufgabenplan und alle
+Freigabegrenzen von /idea gelten weiterhin. Der Befehl funktioniert auch über
+Telegram.
+
 Im automatisch angebundenen Telegram-Kanal werden ausschließlich /loop, /goal,
-/idea und /befehle als Befehle ausgeführt. Ist der Agent beschäftigt, bleiben
+/idea, /chancenradar und /befehle als Befehle ausgeführt. Ist der Agent beschäftigt, bleiben
 sie in der Warteschlange. Andere Slash-Eingaben werden aus Sicherheitsgründen
 als normale Chatnachrichten behandelt.
 
@@ -91,8 +119,11 @@ anschließend mit GetMedia abgerufen.
 Die Medienleiste erscheint nur bei aktiven Medienaufträgen. Sie zeigt
 Warteschlangenplatz, Produktionsphase und Laufzeit sowie nur tatsächlich vom
 Anbieter gemeldete Prozentwerte, Schritte, Frames, FPS, Audiolänge, Restzeit,
-Auflösung, Wellenform und Vorschauen. Aktualisierte Vorschaubilder werden
-erneuert; Medienpfade und Webadressen sind als Terminalverweise anklickbar.
+Auflösung, Wellenform und Vorschauen. Bei Bild-zu-Video erscheint das lokale
+Ausgangsbild sofort als Vorschau. Tatsächlich gemeldete Phasen bleiben erhalten,
+sodass auch kurze Schritte wie Rendern und Speichern in der Produktionskette
+sichtbar sind. Aktualisierte Vorschaubilder werden erneuert; Medienpfade und
+Webadressen sind als Terminalverweise anklickbar.
 
 Aktualisieren
 -------------

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.53
+npm install -g blun-king-cli@9.1.57
 ```
 
 ## Reproduzierbares Staging und Packen
@@ -35,10 +35,30 @@ an. Version, Konto, Modell und Befehle sind ansonsten identisch. Der Unterschied
 gilt nur für den laufenden Prozess; die gespeicherte
 Plugin-Konfiguration wird nicht umgeschrieben.
 
+## Zuverlässiger King-Start
+
+Der Windows-Hilfsprozess für private Pfade übernimmt `TEMP` und `TMP` aus der
+Benutzersitzung. Dadurch kann der C#-Compiler für die ACL-Prüfung auch unter
+einem normalen Benutzerkonto arbeiten. Scheitert der Unterprozess, nennt die
+Fehlermeldung jetzt dessen tatsächliche Ursache.
+
+Ein bereits laufender Telegram-Prozess blockiert Aktualisierungen nicht mehr.
+Unveränderte Plugin-Dateien werden wiederverwendet; geänderte Dateien werden in
+einem inhaltsadressierten Verzeichnis daneben installiert. Der neue Prozess
+verwendet den neuen Pfad, während der bisherige Prozess seinen geladenen Stand
+geordnet beenden kann.
+
 Beim Fortsetzen mit `--continue` oder `--session` wird der Arbeitsbereich der
 bestehenden Sitzung direkt verwendet. Die Ordnerauswahl bleibt neuen Starts
 vorbehalten und kann eine Fortsetzung daher nicht mehr vorzeitig beenden.
 
+## Schnellstart
+
+Beim Starten oder Fortsetzen einer Sitzung werden die Skill-Verzeichnisse
+parallel geprüft und eingelesen. Die Skills werden weiterhin in der
+ursprünglichen, festen Reihenfolge registriert; Priorität und Verhalten bei
+doppelten Namen bleiben unverändert.
+
 ## Zug-Wächter
 
 Läuft ein Zug 20 Minuten ohne neues Werkzeugergebnis, meldet die Konsole den
@@ -78,8 +98,16 @@ Der erste Werkzeugaufruf muss den sichtbaren Plan setzen. Ausgehende Aktionen
 werden zusätzlich pro Werkzeugaufruf geprüft und bei fehlender Kanal- oder
 Zugangsfreigabe angehalten.
 
+`/chancenradar <Ziel>` startet einen eigenen Modus zur Chancensuche. Der Agent
+durchsucht aktuelle öffentliche Quellen, Foren und Communitys nach echten
+Problemen und bestehenden Lösungsansätzen, trennt Belege von Schlussfolgerungen,
+bewertet Chancen nach Wirkung, Passung, Aufwand und Verlässlichkeit und setzt den
+besten sicheren lokalen nächsten Schritt um. Der sichtbare Aufgabenplan und alle
+Freigabegrenzen von `/idea` gelten weiterhin. Der Befehl funktioniert auch über
+Telegram.
+
 Im automatisch angebundenen Telegram-Kanal werden ausschließlich `/loop`,
-`/goal`, `/idea` und `/befehle` als Befehle ausgeführt. Ist der Agent
+`/goal`, `/idea`, `/chancenradar` und `/befehle` als Befehle ausgeführt. Ist der Agent
 beschäftigt, bleiben sie in der Warteschlange. Andere Slash-Eingaben werden aus
 Sicherheitsgründen als normale Chatnachrichten behandelt.
 
@@ -112,8 +140,11 @@ anschließend mit `GetMedia` abgerufen.
 Die Medienleiste erscheint nur bei aktiven Medienaufträgen. Sie zeigt
 Warteschlangenplatz, Produktionsphase und Laufzeit sowie nur tatsächlich vom
 Anbieter gemeldete Prozentwerte, Schritte, Frames, FPS, Audiolänge, Restzeit,
-Auflösung, Wellenform und Vorschauen. Aktualisierte Vorschaubilder werden
-erneuert; Medienpfade und Webadressen sind als Terminalverweise anklickbar.
+Auflösung, Wellenform und Vorschauen. Bei Bild-zu-Video erscheint das lokale
+Ausgangsbild sofort als Vorschau. Tatsächlich gemeldete Phasen bleiben erhalten,
+sodass auch kurze Schritte wie Rendern und Speichern in der Produktionskette
+sichtbar sind. Aktualisierte Vorschaubilder werden erneuert; Medienpfade und
+Webadressen sind als Terminalverweise anklickbar.
 
 ## Aktualisieren
 

package/bin/plugin-bootstrap.js

@@ -1,12 +1,13 @@
 'use strict';
 
-const { randomUUID } = require('node:crypto');
+const { createHash, randomUUID } = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
 
 const {
   ensurePrivateDirectory,
   securePrivateFile,
+  securePrivateTree,
   writePrivateFile,
 } = require('./private-paths');
 
@@ -14,6 +15,76 @@ function isObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+function snapshotPluginTree(root) {
+  const entries = [];
+  const visit = (directory, relativeDirectory = '') => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })
+      .sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0)) {
+      const relativePath = path.join(relativeDirectory, entry.name);
+      const absolutePath = path.join(directory, entry.name);
+      const stat = fs.lstatSync(absolutePath);
+      if (stat.isSymbolicLink()) return false;
+      if (stat.isDirectory()) {
+        entries.push({ kind: 'directory', path: relativePath });
+        if (!visit(absolutePath, relativePath)) return false;
+      } else if (stat.isFile()) {
+        entries.push({
+          kind: 'file',
+          path: relativePath,
+          content: fs.readFileSync(absolutePath),
+        });
+      } else {
+        return false;
+      }
+    }
+    return true;
+  };
+  return visit(root) ? entries : null;
+}
+
+function pluginTreesAreIdentical(sourceRoot, pluginRoot) {
+  try {
+    const source = snapshotPluginTree(sourceRoot);
+    const installed = snapshotPluginTree(pluginRoot);
+    if (source === null || installed === null || source.length !== installed.length) return false;
+    return source.every((entry, index) => {
+      const other = installed[index];
+      return entry.kind === other.kind
+        && entry.path === other.path
+        && (entry.kind !== 'file' || entry.content.equals(other.content));
+    });
+  } catch {
+    return false;
+  }
+}
+
+function pluginTreeDigest(root) {
+  const entries = snapshotPluginTree(root);
+  if (entries === null) throw new Error(`Invalid managed plugin tree: ${root}`);
+  const hash = createHash('sha256');
+  for (const entry of entries) {
+    const metadata = Buffer.from(`${entry.kind}\0${entry.path}\0`, 'utf8');
+    hash.update(metadata);
+    if (entry.kind === 'file') {
+      const length = Buffer.allocUnsafe(8);
+      length.writeBigUInt64BE(BigInt(entry.content.length));
+      hash.update(length);
+      hash.update(entry.content);
+    }
+  }
+  return hash.digest('hex');
+}
+
+function hasCurrentTelegramRecord(installed, pluginRoot) {
+  const records = installed.plugins.filter((plugin) => plugin.id === 'telegram');
+  if (records.length !== 1) return false;
+  const [telegram] = records;
+  return telegram.root === pluginRoot
+    && telegram.source === 'local-path'
+    && telegram.enabled === true
+    && telegram.capabilities?.mcpServers?.telegram?.enabled === true;
+}
+
 function readInstalledPlugins(filePath) {
   if (!fs.existsSync(filePath)) return { version: 1, plugins: [] };
 
@@ -82,43 +153,52 @@ function installManagedTelegramPlugin({ packageRoot, blunDir, now = new Date().t
   const sourceRoot = path.join(packageRoot, 'telegram-plugin');
   const pluginsDir = path.join(blunDir, 'plugins');
   const managedDir = path.join(pluginsDir, 'managed');
-  const pluginRoot = path.join(managedDir, 'telegram');
+  const legacyPluginRoot = path.join(managedDir, 'telegram');
   const installedFile = path.join(pluginsDir, 'installed.json');
 
   ensurePrivateDirectory(pluginsDir);
   if (fs.existsSync(installedFile)) securePrivateFile(installedFile);
   const installed = readInstalledPlugins(installedFile);
-  const updatedInstalled = updatedInstalledPlugins(installed, pluginRoot, now);
   ensurePrivateDirectory(managedDir);
+  if (fs.existsSync(legacyPluginRoot)
+    && pluginTreesAreIdentical(sourceRoot, legacyPluginRoot)) {
+    if (!hasCurrentTelegramRecord(installed, legacyPluginRoot)) {
+      const updatedInstalled = updatedInstalledPlugins(installed, legacyPluginRoot, now);
+      writeInstalledPlugins(installedFile, updatedInstalled);
+    }
+    return { installedFile, pluginRoot: legacyPluginRoot, reused: true };
+  }
+  const sourceDigest = pluginTreeDigest(sourceRoot);
+  const pluginRoot = path.join(managedDir, `telegram-${sourceDigest}`);
+  const updatedInstalled = updatedInstalledPlugins(installed, pluginRoot, now);
+  if (fs.existsSync(pluginRoot)) {
+    if (!pluginTreesAreIdentical(sourceRoot, pluginRoot)) {
+      throw new Error(`Managed Telegram plugin digest mismatch: ${pluginRoot}`);
+    }
+    if (!hasCurrentTelegramRecord(installed, pluginRoot)) {
+      writeInstalledPlugins(installedFile, updatedInstalled);
+    }
+    return { installedFile, pluginRoot, reused: true };
+  }
   const nonce = `${process.pid}-${randomUUID()}`;
   const stagingRoot = path.join(managedDir, `.telegram-${nonce}.tmp`);
-  const backupRoot = path.join(managedDir, `.telegram-${nonce}.bak`);
-  let hadPreviousPlugin = false;
   let installedNewPlugin = false;
   try {
-    if (fs.existsSync(pluginRoot)) {
-      ensurePrivateDirectory(pluginRoot);
-      hadPreviousPlugin = true;
-    }
     fs.cpSync(sourceRoot, stagingRoot, { recursive: true, force: true });
-    if (hadPreviousPlugin) fs.renameSync(pluginRoot, backupRoot);
+    securePrivateTree(stagingRoot);
     try {
       fs.renameSync(stagingRoot, pluginRoot);
       installedNewPlugin = true;
       writeInstalledPlugins(installedFile, updatedInstalled);
     } catch (error) {
       if (installedNewPlugin) fs.rmSync(pluginRoot, { recursive: true, force: true });
-      if (hadPreviousPlugin && fs.existsSync(backupRoot)) {
-        fs.renameSync(backupRoot, pluginRoot);
-      }
       throw error;
     }
-    if (hadPreviousPlugin) fs.rmSync(backupRoot, { recursive: true, force: true });
   } finally {
     fs.rmSync(stagingRoot, { recursive: true, force: true });
   }
 
-  return { installedFile, pluginRoot };
+  return { installedFile, pluginRoot, reused: false };
 }
 
 module.exports = {

package/bin/private-paths.js

@@ -11,6 +11,7 @@ const PRIVATE_TREE_MAX_DEPTH = 64;
 const PRIVATE_TREE_MAX_ENTRIES = 4096;
 const PRIVATE_TREE_MAX_PATH_LENGTH = 4096;
 const WINDOWS_ACL_OK_SENTINEL = 'BLUN_PRIVATE_ACL_OK_V1';
+const WINDOWS_ACL_ERROR_SENTINEL = 'BLUN_PRIVATE_ACL_ERROR_V1';
 const WINDOWS_SID_PATTERN = /S-\d-\d+(?:-\d+)+/gi;
 const WINDOWS_LOCAL_DOS_PATH_PATTERN = /^[A-Za-z]:\\/u;
 const WINDOWS_RESERVED_PATH_SEGMENT = /^(?:CON|PRN|AUX|NUL|CONIN\$|CONOUT\$|COM[1-9]|LPT[1-9])(?:\..*)?$/iu;
@@ -33,6 +34,9 @@ public static class BlunPrivateAclNative
     private const uint READ_CONTROL = 0x00020000;
     private const uint WRITE_DAC = 0x00040000;
     private const uint SYNCHRONIZE = 0x00100000;
+    private const uint FILE_SHARE_READ = 0x00000001;
+    private const uint FILE_SHARE_WRITE = 0x00000002;
+    private const uint FILE_SHARE_DELETE = 0x00000004;
     private const uint CREATE_NEW = 1;
     private const uint OPEN_EXISTING = 3;
     private const uint FILE_ATTRIBUTE_NORMAL = 0x00000080;
@@ -607,7 +611,7 @@ public static class BlunPrivateAclNative
                 out ioStatus,
                 IntPtr.Zero,
                 0,
-                0,
+                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                 FILE_OPEN_IF,
                 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_REPARSE_POINT,
                 IntPtr.Zero,
@@ -1108,7 +1112,7 @@ const WINDOWS_ACL_SCRIPT = [
   "[Console]::Out.Write('BLUN_PRIVATE_ACL_OK_V1')",
   'exit 0',
   '} catch {',
-  "[Console]::Error.Write('BLUN_PRIVATE_ACL_ERROR_V1')",
+  "[Console]::Error.Write('BLUN_PRIVATE_ACL_ERROR_V1|' + $_.Exception.GetType().FullName + '|' + $_.Exception.Message)",
   'exit 1',
   '}',
 ].join('\n');
@@ -1127,9 +1131,18 @@ function windowsSystemDirectory(options) {
   return path.win32.normalize(directory);
 }
 
-function windowsHostEnvironment(systemDirectory) {
+function windowsHostEnvironment(systemDirectory, env = process.env) {
   const systemRoot = path.win32.dirname(systemDirectory);
-  return { SystemRoot: systemRoot, WINDIR: systemRoot };
+  const temporaryDirectory = env.TEMP || env.TMP;
+  if (!temporaryDirectory) {
+    throw new Error('Windows private ACL temporary directory is unavailable.');
+  }
+  return {
+    SystemRoot: systemRoot,
+    WINDIR: systemRoot,
+    TEMP: temporaryDirectory,
+    TMP: env.TMP || temporaryDirectory,
+  };
 }
 
 function runWindowsCommand(executable, args, options, env, input) {
@@ -1190,14 +1203,14 @@ function resolveWindowsPrivateTarget(targetPath) {
       throw new Error('Invalid Windows private path.');
     }
     return absoluteTarget;
-  } catch {
-    throw new Error('Windows private ACL hardening or verification failed.');
+  } catch (error) {
+    throw new Error('Windows private path validation failed.', { cause: error });
   }
 }
 
 function windowsAclController(options) {
   const systemDirectory = windowsSystemDirectory(options);
-  const hostEnvironment = windowsHostEnvironment(systemDirectory);
+  const hostEnvironment = windowsHostEnvironment(systemDirectory, options.env || process.env);
   const whoami = path.win32.join(systemDirectory, 'whoami.exe');
   const powershell = path.win32.join(
     systemDirectory,
@@ -1235,7 +1248,7 @@ function windowsAclController(options) {
       if (!path.isAbsolute(absoluteTarget)
         || root.toLowerCase() === absoluteTarget.toLowerCase()
         || !['directory', 'file', 'file-write', 'tree'].includes(kind)) {
-        throw new Error('Windows private ACL hardening or verification failed.');
+        throw new Error('Windows private ACL target validation failed.');
       }
       const env = {
         ...hostEnvironment,
@@ -1253,11 +1266,21 @@ function windowsAclController(options) {
           env,
           input,
         );
-      } catch {
-        throw new Error('Windows private ACL hardening or verification failed.');
+      } catch (error) {
+        const stderr = typeof error?.stderr === 'string'
+          ? error.stderr : Buffer.isBuffer(error?.stderr) ? error.stderr.toString('utf8') : '';
+        const marker = `${WINDOWS_ACL_ERROR_SENTINEL}|`;
+        const rawDetail = stderr.startsWith(marker) ? stderr.slice(marker.length) : '';
+        const detail = rawDetail.replace(/[\u0000-\u001f\u007f]+/gu, ' ').trim().slice(0, 500);
+        throw new Error(
+          detail.length > 0
+            ? `Windows private ACL operation failed for ${kind} target "${absoluteTarget}": ${detail}`
+            : `Windows private ACL operation failed for ${kind} target "${absoluteTarget}".`,
+          { cause: error },
+        );
       }
       if (output !== WINDOWS_ACL_OK_SENTINEL) {
-        throw new Error('Windows private ACL hardening or verification failed.');
+        throw new Error('Windows private ACL verification returned an unexpected response.');
       }
     } finally {
       input?.fill(0);

package/blun.mjs

@@ -235059,15 +235059,25 @@ async function discoverSkills(options) {
 		}
 		const directorySkills = /* @__PURE__ */ new Set();
 		const subdirs = [];
-		for (const entry of entries) {
+		const classifiedEntries = await Promise.all(entries.map(async (entry) => {
 			const entryPath = posix$2.join(dirPath, entry);
-			if (await isFile(posix$2.join(entryPath, "SKILL.md"))) directorySkills.add(entry);
-			if (entry === "node_modules" || entry.startsWith(".")) continue;
-			if (await isDir(entryPath)) subdirs.push(entry);
+			const [hasSkillFile, directory] = await Promise.all([
+				isFile(posix$2.join(entryPath, "SKILL.md")),
+				entry === "node_modules" || entry.startsWith(".") ? false : isDir(entryPath)
+			]);
+			return {
+				entry,
+				hasSkillFile,
+				directory
+			};
+		}));
+		for (const classified of classifiedEntries) {
+			if (classified.hasSkillFile) directorySkills.add(classified.entry);
+			if (classified.directory) subdirs.push(classified.entry);
 		}
 		const allowedSubSkillBundles = /* @__PURE__ */ new Map();
-		for (const entry of directorySkills) {
-			const skill = await parseAndRegister({
+		const directorySkillEntries = [...directorySkills];
+		const directorySkillResults = await parseAndRegisterAll(directorySkillEntries.map((entry) => ({
 				parse,
 				byName,
 				skillMdPath: posix$2.join(dirPath, entry, "SKILL.md"),
@@ -235077,7 +235087,10 @@ async function discoverSkills(options) {
 				warn,
 				skip,
 				subSkillParentName
-			});
+			})));
+		for (let index = 0; index < directorySkillEntries.length; index++) {
+			const entry = directorySkillEntries[index];
+			const skill = directorySkillResults[index];
 			if (skill !== void 0 && hasSubSkillEnabled(skill)) allowedSubSkillBundles.set(entry, skill.name);
 		}
 		if (isTopLevel) {
@@ -235094,6 +235107,7 @@ async function discoverSkills(options) {
 					skip
 				});
 			}
+			const flatInputs = [];
 			for (const entry of entries) {
 				if (!entry.endsWith(".md")) continue;
 				if (entry === "SKILL.md") continue;
@@ -235104,7 +235118,7 @@ async function discoverSkills(options) {
 				}
 				const skillMdPath = posix$2.join(dirPath, entry);
 				if (!await isFile(skillMdPath)) continue;
-				await parseAndRegister({
+				flatInputs.push({
 					parse,
 					byName,
 					skillMdPath,
@@ -235115,6 +235129,7 @@ async function discoverSkills(options) {
 					skip
 				});
 			}
+			await parseAndRegisterAll(flatInputs);
 		}
 		for (const entry of subdirs) {
 			if (directorySkills.has(entry) && !allowedSubSkillBundles.has(entry)) continue;
@@ -235181,7 +235196,7 @@ async function pushProvidedRoot(out, root, isDir, realpath) {
 	};
 	return true;
 }
-async function parseAndRegister(input) {
+async function parseSkillCandidate(input) {
 	try {
 		const parsed = await input.parse({
 			skillMdPath: input.skillMdPath,
@@ -235201,9 +235216,6 @@ async function parseAndRegister(input) {
 			...skill,
 			plugin: input.root.plugin
 		};
-		input.onDiscoveredSkill?.(discovered);
-		const key = normalizeSkillName(discovered.name);
-		if (!input.byName.has(key)) input.byName.set(key, discovered);
 		return discovered;
 	} catch (error) {
 		if (error instanceof UnsupportedSkillTypeError) input.skip({
@@ -235216,6 +235228,20 @@ async function parseAndRegister(input) {
 		return;
 	}
 }
+function registerSkillCandidate(input, discovered) {
+	if (discovered === void 0) return;
+	input.onDiscoveredSkill?.(discovered);
+	const key = normalizeSkillName(discovered.name);
+	if (!input.byName.has(key)) input.byName.set(key, discovered);
+	return discovered;
+}
+async function parseAndRegister(input) {
+	return registerSkillCandidate(input, await parseSkillCandidate(input));
+}
+async function parseAndRegisterAll(inputs) {
+	const discovered = await Promise.all(inputs.map((input) => parseSkillCandidate(input)));
+	return discovered.map((skill, index) => registerSkillCandidate(inputs[index], skill));
+}
 function qualifySubSkillName(parentName, skillName) {
 	if (skillName === parentName || skillName.startsWith(`${parentName}.`)) return skillName;
 	return `${parentName}.${skillName}`;
@@ -262010,6 +262036,14 @@ function isMediaToolName(name) {
 		"GetMedia"
 	].includes(name);
 }
+const MEDIA_INLINE_PREVIEW_MAX_BYTES = 1536 * 1024;
+function mediaInlinePreviewPayload(data, mimeType) {
+	if (data.byteLength === 0 || data.byteLength > MEDIA_INLINE_PREVIEW_MAX_BYTES) return {};
+	return {
+		previewDataBase64: Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("base64"),
+		previewMimeType: mimeType
+	};
+}
 function emitMediaProgress(ctx, toolName, phase, data = {}) {
 	ctx.onUpdate({
 		kind: "custom",
@@ -262163,6 +262197,7 @@ var init_blun_media$1 = __esmMin((() => {
 					isError: true,
 					output: `"${args.path}" is empty.`
 				};
+				emitMediaProgress(ctx, this.name, "uploading", mediaInlinePreviewPayload(data, fileType.mimeType));
 				const options = {
 					signal: ctx.signal,
 					toolCallId: ctx.toolCallId
@@ -310934,6 +310969,14 @@ function mediaPayloadNumberArray(payload, keys) {
 		if (samples.length > 0) return samples.slice(0, 512);
 	}
 }
+function mediaPayloadTextArray(payload, keys) {
+	for (const key of keys) {
+		const value = payload[key];
+		if (!Array.isArray(value)) continue;
+		const entries = value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+		if (entries.length > 0) return entries.slice(-32);
+	}
+}
 function mediaProgressFromPayload(payload) {
 	const nestedProgress = payload["progress"];
 	const source = typeof nestedProgress === "object" && nestedProgress !== null && !Array.isArray(nestedProgress) ? {
@@ -310964,7 +311007,8 @@ function mediaProgressFromPayload(payload) {
 		previewMimeType: mediaPayloadText(source, ["preview_mime_type", "previewMimeType", "thumbnail_mime_type", "thumbnailMimeType"]),
 		sampleUrl: mediaPayloadText(source, ["sample_url", "sampleUrl", "audio_preview_url", "audioPreviewUrl"]),
 		localPath: mediaPayloadText(source, ["local_path", "localPath"]),
-		waveform: mediaPayloadNumberArray(source, ["waveform", "waveform_samples", "waveformSamples"])
+		waveform: mediaPayloadNumberArray(source, ["waveform", "waveform_samples", "waveformSamples"]),
+		phaseHistory: mediaPayloadTextArray(source, ["phase_history", "phaseHistory"])
 	};
 	return Object.fromEntries(Object.entries(progress).filter(([, value]) => value !== void 0));
 }
@@ -401409,6 +401453,21 @@ const BUILTIN_SLASH_COMMAND_DEFINITIONS = [
 			return "idle-only";
 		}
 	},
+	{
+		name: "chancenradar",
+		aliases: [],
+		descriptionKey: "command.idea.description",
+		priority: 80,
+		argumentHint: "<objective>",
+		availability: (args) => {
+			const trimmed = args.trim();
+			if (trimmed === "") return "always";
+			const tokens = trimmed.split(/\s+/);
+			const action = tokens[0]?.toLowerCase();
+			if (tokens.length === 1 && (action === "status" || action === "pause" || action === "paused" || action === "resume" || action === "cancel" || action === "clear" || action === "stop")) return "always";
+			return "idle-only";
+		}
+	},
 	{
 		name: "loop",
 		aliases: [],
@@ -416698,7 +416757,7 @@ function bufferContext(state, chatId, tag) {
 function channelOrigin(envelope) {
 	return `Telegram · ${envelope.meta.user ?? envelope.meta.chat_id}`;
 }
-const TELEGRAM_REMOTE_COMMANDS = Object.freeze(["loop", "goal", "idea", "befehle"]);
+const TELEGRAM_REMOTE_COMMANDS = Object.freeze(["loop", "goal", "idea", "chancenradar", "befehle"]);
 function telegramRemoteCommand(text) {
 	const trimmed = text.trim();
 	const parsed = parseSlashInput(trimmed);
@@ -416912,19 +416971,25 @@ function sessionMcpServers() {
 	return telegramChannelMcpServers();
 }
 function managedTelegramPluginEnabled() {
+	return managedTelegramPluginRoot() !== void 0;
+}
+function managedTelegramPluginRoot() {
 	const blunHome = join(homedir(), ".blun");
-	const managedRoot = join(blunHome, "plugins", "managed", "telegram");
-	if (!existsSync(join(managedRoot, "dist", "mcp-server.mjs"))) return false;
 	try {
-		return JSON.parse(readFileSync(join(blunHome, "plugins", "installed.json"), "utf8")).plugins?.some((plugin) => plugin.id === "telegram" && plugin.enabled === true && (typeof plugin.root !== "string" || plugin.root === managedRoot)) ?? false;
+		const telegram = JSON.parse(readFileSync(join(blunHome, "plugins", "installed.json"), "utf8")).plugins?.find((plugin) => plugin.id === "telegram" && plugin.enabled === true);
+		if (typeof telegram?.root !== "string" || telegram.root.length === 0) return void 0;
+		if (!existsSync(join(telegram.root, "dist", "mcp-server.mjs"))) return void 0;
+		return telegram.root;
 	} catch {
-		return false;
+		return void 0;
 	}
 }
 function resolveTelegramMcpEntry() {
 	const main = process.argv[1];
+	const managedRoot = managedTelegramPluginRoot();
 	const candidates = [
 		process.env["BLUN_TELEGRAM_MCP_SERVER"],
+		managedRoot === void 0 ? void 0 : join(managedRoot, "dist", "mcp-server.mjs"),
 		join(homedir(), ".blun", "plugins", "managed", "telegram", "dist", "mcp-server.mjs"),
 		main === void 0 ? void 0 : join(dirname(main), "..", "..", "..", "plugins", "telegram", "dist", "mcp-server.mjs")
 	];
@@ -417330,8 +417395,10 @@ var TelegramChannelController = class {
 	}
 	resolveBridgeEntry() {
 		const main = process.argv[1];
+		const managedRoot = managedTelegramPluginRoot();
 		const candidates = [
 			process.env["BLUN_TELEGRAM_BRIDGE"],
+			managedRoot === void 0 ? void 0 : join(managedRoot, "dist", "bridge.mjs"),
 			join(homedir(), ".blun", "plugins", "managed", "telegram", "dist", "bridge.mjs"),
 			main === void 0 ? void 0 : join(dirname(main), "..", "..", "..", "plugins", "telegram", "dist", "bridge.mjs")
 		];
@@ -420255,6 +420322,42 @@ async function handleIdeaCommand(host, args) {
 		}
 	});
 }
+const CHANCE_RADAR_CONTRACT_MARKER = "Operate as an evidence-driven opportunity radar:";
+function buildChanceRadarContract() {
+	return `${buildIdeaContract()}
+
+${CHANCE_RADAR_CONTRACT_MARKER} search current public sources, relevant forums, communities, reviews, and competing approaches for concrete unmet needs. Prefer multiple independent sources when available. Preserve the source URL and retrieval date for material evidence. Never invent demand, users, quotes, reach, or market size.
+
+Separate observations, inferences, and unknowns. For every serious opportunity record the problem, affected people, evidence, existing alternatives, fit with the user's objective, likely impact, implementation effort, and confidence. Justify every ranking; a numeric score without evidence is not a finding. Drop weak or duplicated opportunities instead of padding the list.
+
+Choose the strongest supported opportunity, update TodoList with the decision, and execute the best safe local next step. Ask a focused question only when the answer changes the ranking or next action. Keep all Idea-mode approval and access boundaries in force.`;
+}
+function buildChanceRadarPrompt(objective) {
+	return `<chance-radar-mode>
+The user's objective is:
+${objective}
+
+Your first tool call MUST be TodoList. Publish a task-specific discovery, research, ranking, and execution plan before any research or action.
+
+${buildChanceRadarContract()}
+</chance-radar-mode>`;
+}
+async function handleChanceRadarCommand(host, args) {
+	const parsed = parseGoalCommand(args);
+	if (parsed.kind !== "create") {
+		await handleGoalCommand(host, args);
+		return;
+	}
+	await createGoal(host, {
+		...parsed,
+		completionCriterion: buildChanceRadarContract()
+	}, args, {
+		commandName: "chancenradar",
+		sendInput: (objective) => {
+			host.sendMessage(host.requireSession(), objective, { parts: buildChanceRadarPrompt(objective) });
+		}
+	});
+}
 function parseNextGoalCommand(tokens) {
 	if (tokens.length === 2 && tokens[1]?.toLowerCase() === "manage") return { kind: "next-manage" };
 	let index = 1;
@@ -493272,6 +493375,9 @@ async function handleBuiltInSlashCommand(host, name, args) {
 		case "idea":
 			await handleIdeaCommand(host, args);
 			return;
+		case "chancenradar":
+			await handleChanceRadarCommand(host, args);
+			return;
 		case "loop":
 			await handleLoopCommand(host, args);
 			return;
@@ -498562,6 +498668,10 @@ var MediaActivityStore = class {
 		const mediaKind = event.mediaKind === "media" && previous?.mediaKind !== void 0 ? previous.mediaKind : event.mediaKind ?? previous?.mediaKind ?? "media";
 		const phase = mediaActivityStatusKey(event.phase ?? previous?.phase ?? "processing");
 		const phaseHistory = [...previous?.phaseHistory ?? []];
+		if (Array.isArray(event.phaseHistory)) for (const reportedPhase of event.phaseHistory) {
+			const normalized = mediaActivityStatusKey(reportedPhase);
+			if (phaseHistory.at(-1) !== normalized) phaseHistory.push(normalized);
+		}
 		if (phaseHistory.at(-1) !== phase) phaseHistory.push(phase);
 		this.jobs.set(key, {
 			...previous,
@@ -513379,7 +513489,6 @@ var BlunTUI = class {
 		this.showStatus(warning, "warning");
 	}
 	async init() {
-		if (this.startupWorkspaceSelectionPending) return false;
 		await this.measureStartupPhase("experimental_ms", async () => {
 			setExperimentalFeatures(await this.harness.getExperimentalFeatures());
 		});
@@ -513392,6 +513501,7 @@ var BlunTUI = class {
 			} else this.authFlow.enterManagedAccountUnavailableStartupState(accountContext.kind);
 			return false;
 		}
+		if (this.startupWorkspaceSelectionPending) return false;
 		await this.measureStartupPhase("provider_models_ms", () => this.refreshProviderModelsBeforeSession());
 		const { startup } = this.options;
 		const { workDir } = this.state.appState;
@@ -514089,7 +514199,7 @@ var BlunTUI = class {
 		};
 		this.telegramRemoteCommandContext = context;
 		const execution = item.telegramCommandName === "befehle" ? Promise.resolve().then(() => {
-			context.responses.push("/loop\n/goal\n/idea\n/befehle");
+			context.responses.push("/loop\n/goal\n/idea\n/chancenradar\n/befehle");
 		}) : dispatchInput(this, item.text);
 		execution.catch((error) => {
 			this.showError(formatErrorMessage$2(error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.53",
+  "version": "9.1.58",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {