blun-king-cli 9.1.587 → 9.1.588

package/bin/plugin-bootstrap.js

@@ -3,62 +3,18 @@
 const { randomUUID } = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
-const { snapshotPluginTree, digestPluginEntries, selectedAgentSpineRoot } = require('./managed-plugin-selection.cjs');
+const { selectedAgentSpineRoot, describeAgentSpineSelection, copySelectedAgentSpinePlugin } = require('./managed-plugin-selection.cjs');
 
 const {
   ensurePrivateDirectory,
   securePrivateFile,
-  securePrivateTree,
   writePrivateFile,
 } = require('./private-paths');
 
-const managedPluginSourceSnapshots = new Map();
-
 function isObject(value) {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-function snapshotManagedPluginSource(root) {
-  const resolvedRoot = path.resolve(root);
-  const cacheKey = process.platform === 'win32' ? resolvedRoot.toLowerCase() : resolvedRoot;
-  if (!managedPluginSourceSnapshots.has(cacheKey)) {
-    managedPluginSourceSnapshots.set(cacheKey, snapshotPluginTree(resolvedRoot));
-  }
-  return managedPluginSourceSnapshots.get(cacheKey);
-}
-
-function pluginTreesAreIdentical(sourceRoot, pluginRoot) {
-  try {
-    const source = snapshotManagedPluginSource(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 = snapshotManagedPluginSource(root);
-  if (entries === null) throw new Error(`Invalid managed plugin tree: ${root}`);
-  return digestPluginEntries(entries);
-}
-
-function hasCurrentPluginRecord(installed, pluginRoot, pluginId, mcpServerName) {
-  const records = installed.plugins.filter((plugin) => plugin.id === pluginId);
-  if (records.length !== 1) return false;
-  const [plugin] = records;
-  return plugin.root === pluginRoot
-    && plugin.source === 'local-path'
-    && plugin.enabled === true
-    && plugin.capabilities?.mcpServers?.[mcpServerName]?.enabled === true;
-}
-
 function readInstalledPlugins(filePath) {
   if (!fs.existsSync(filePath)) return { version: 1, plugins: [] };
 
@@ -70,14 +26,14 @@ function readInstalledPlugins(filePath) {
   return parsed;
 }
 
-function updatedInstalledPlugins(installed, pluginRoot, now, pluginId, mcpServerName) {
+function updatedInstalledPlugins(installed, pluginRoot, now, pluginId = 'telegram') {
   const previous = installed.plugins.find((plugin) => plugin.id === pluginId);
   const previousCapabilities = isObject(previous?.capabilities) ? previous.capabilities : {};
   const previousMcpServers = isObject(previousCapabilities.mcpServers)
     ? previousCapabilities.mcpServers : {};
-  const previousMcp = isObject(previousMcpServers[mcpServerName])
-    ? previousMcpServers[mcpServerName] : {};
-  const updatedPlugin = {
+  const previousTelegramMcp = isObject(previousMcpServers[pluginId])
+    ? previousMcpServers[pluginId] : {};
+  const telegram = {
     ...previous,
     id: pluginId,
     root: pluginRoot,
@@ -90,7 +46,7 @@ function updatedInstalledPlugins(installed, pluginRoot, now, pluginId, mcpServer
       ...previousCapabilities,
       mcpServers: {
         ...previousMcpServers,
-        [mcpServerName]: { ...previousMcp, enabled: true },
+        [pluginId]: { ...previousTelegramMcp, enabled: previousTelegramMcp.enabled === false && pluginId === 'agent-spine' ? false : true },
       },
     },
   };
@@ -101,11 +57,11 @@ function updatedInstalledPlugins(installed, pluginRoot, now, pluginId, mcpServer
     if (plugin.id !== pluginId) {
       plugins.push(plugin);
     } else if (!replaced) {
-      plugins.push(updatedPlugin);
+      plugins.push(telegram);
       replaced = true;
     }
   }
-  if (!replaced) plugins.push(updatedPlugin);
+  if (!replaced) plugins.push(telegram);
   return { ...installed, version: 1, plugins };
 }
 
@@ -123,100 +79,80 @@ function writeInstalledPlugins(filePath, installed) {
   }
 }
 
-function installManagedPlugin({
-  packageRoot,
-  blunDir,
-  now = new Date().toISOString(),
-  pluginId,
-  sourceDirectory,
-  mcpServerName,
-  displayName,
-}) {
-  const sourceRoot = path.join(packageRoot, sourceDirectory);
+function installManagedTelegramPlugin({ packageRoot, blunDir, now = new Date().toISOString() }) {
+  const sourceRoot = path.join(packageRoot, 'telegram-plugin');
   const pluginsDir = path.join(blunDir, 'plugins');
   const managedDir = path.join(pluginsDir, 'managed');
-  const legacyPluginRoot = path.join(managedDir, pluginId);
+  const pluginRoot = 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 (pluginId === 'agent-spine') {
-    const selected = selectedAgentSpineRoot({ installed, blunDir });
-    if (selected) return { installedFile, pluginRoot: selected, reused: true, selected: true };
-  }
-  if (fs.existsSync(legacyPluginRoot)
-    && pluginTreesAreIdentical(sourceRoot, legacyPluginRoot)) {
-    if (!hasCurrentPluginRecord(installed, legacyPluginRoot, pluginId, mcpServerName)) {
-      const updatedInstalled = updatedInstalledPlugins(
-        installed,
-        legacyPluginRoot,
-        now,
-        pluginId,
-        mcpServerName,
-      );
-      writeInstalledPlugins(installedFile, updatedInstalled);
-    }
-    return { installedFile, pluginRoot: legacyPluginRoot, reused: true };
-  }
-  const sourceDigest = pluginTreeDigest(sourceRoot);
-  const pluginRoot = path.join(managedDir, `${pluginId}-${sourceDigest}`);
-  const updatedInstalled = updatedInstalledPlugins(
-    installed,
-    pluginRoot,
-    now,
-    pluginId,
-    mcpServerName,
-  );
-  if (fs.existsSync(pluginRoot)) {
-    if (!pluginTreesAreIdentical(sourceRoot, pluginRoot)) {
-      throw new Error(`Managed ${displayName} plugin digest mismatch: ${pluginRoot}`);
-    }
-    if (!hasCurrentPluginRecord(installed, pluginRoot, pluginId, mcpServerName)) {
-      writeInstalledPlugins(installedFile, updatedInstalled);
-    }
-    return { installedFile, pluginRoot, reused: true };
-  }
   const nonce = `${process.pid}-${randomUUID()}`;
-  const stagingRoot = path.join(managedDir, `.${pluginId}-${nonce}.tmp`);
+  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 });
-    securePrivateTree(stagingRoot);
+    if (hadPreviousPlugin) fs.renameSync(pluginRoot, backupRoot);
     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, reused: false };
-}
-
-function installManagedTelegramPlugin(options) {
-  return installManagedPlugin({
-    ...options,
-    pluginId: 'telegram',
-    sourceDirectory: 'telegram-plugin',
-    mcpServerName: 'telegram',
-    displayName: 'Telegram',
-  });
+  return { installedFile, pluginRoot };
 }
 
-function installManagedAgentSpinePlugin(options) {
-  return installManagedPlugin({
-    ...options,
-    pluginId: 'agent-spine',
-    sourceDirectory: 'agent-spine-plugin',
-    mcpServerName: 'agent-spine',
-    displayName: 'AgentSpine',
-  });
+function installManagedAgentSpinePlugin({ packageRoot, blunDir, now = new Date().toISOString() }) {
+  const installedFile = path.join(blunDir, 'plugins', 'installed.json');
+  ensurePrivateDirectory(path.dirname(installedFile));
+  if (fs.existsSync(installedFile)) securePrivateFile(installedFile);
+  const installed = readInstalledPlugins(installedFile);
+  const records = installed.plugins.filter(plugin => plugin.id === 'agent-spine');
+  if (records.length > 1) throw new Error('Ambiguous AgentSpine registration');
+  const selected = selectedAgentSpineRoot({ installed, blunDir });
+  if (selected) return { installedFile, pluginRoot: selected, reused: true, selected: true };
+  if (records[0]?.enabled === false) {
+    return { installedFile, pluginRoot: records[0].root, reused: true, disabled: true };
+  }
+  if (records[0]) {
+    const currentRoot = records[0].root;
+    if (typeof currentRoot !== 'string' || !path.isAbsolute(currentRoot)) {
+      throw new Error('Invalid AgentSpine registration root');
+    }
+    const managed = path.resolve(blunDir, 'plugins', 'managed');
+    const sameDirectory = (left, right) => process.platform === 'win32'
+      ? left.toLowerCase() === right.toLowerCase() : left === right;
+    if (!sameDirectory(path.dirname(path.resolve(currentRoot)), managed)
+      || !/^agent-spine-[a-f0-9]{64}$/.test(path.basename(currentRoot))) {
+      return { installedFile, pluginRoot: currentRoot, reused: true, custom: true };
+    }
+    // An upgrade must not conceal changes to the previous immutable default.
+    describeAgentSpineSelection({ blunDir, pluginRoot: currentRoot });
+  }
+  const pluginRoot = copySelectedAgentSpinePlugin({ blunDir, sourceRoot: path.join(packageRoot, 'agent-spine-plugin') });
+  if (records[0]?.root === pluginRoot) return { installedFile, pluginRoot, reused: true };
+  writeInstalledPlugins(installedFile, updatedInstalledPlugins(installed, pluginRoot, now, 'agent-spine'));
+  return { installedFile, pluginRoot, reused: false };
 }
 
 module.exports = {

package/bin/private-paths.js

@@ -11,7 +11,6 @@ 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;
@@ -34,9 +33,6 @@ 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;
@@ -611,7 +607,7 @@ public static class BlunPrivateAclNative
                 out ioStatus,
                 IntPtr.Zero,
                 0,
-                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                0,
                 FILE_OPEN_IF,
                 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_REPARSE_POINT,
                 IntPtr.Zero,
@@ -1112,7 +1108,7 @@ const WINDOWS_ACL_SCRIPT = [
   "[Console]::Out.Write('BLUN_PRIVATE_ACL_OK_V1')",
   'exit 0',
   '} catch {',
-  "[Console]::Error.Write('BLUN_PRIVATE_ACL_ERROR_V1|' + $_.Exception.GetType().FullName + '|' + $_.Exception.Message)",
+  "[Console]::Error.Write('BLUN_PRIVATE_ACL_ERROR_V1')",
   'exit 1',
   '}',
 ].join('\n');
@@ -1131,18 +1127,9 @@ function windowsSystemDirectory(options) {
   return path.win32.normalize(directory);
 }
 
-function windowsHostEnvironment(systemDirectory, env = process.env) {
+function windowsHostEnvironment(systemDirectory) {
   const systemRoot = path.win32.dirname(systemDirectory);
-  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,
-  };
+  return { SystemRoot: systemRoot, WINDIR: systemRoot };
 }
 
 function runWindowsCommand(executable, args, options, env, input) {
@@ -1203,14 +1190,14 @@ function resolveWindowsPrivateTarget(targetPath) {
       throw new Error('Invalid Windows private path.');
     }
     return absoluteTarget;
-  } catch (error) {
-    throw new Error('Windows private path validation failed.', { cause: error });
+  } catch {
+    throw new Error('Windows private ACL hardening or verification failed.');
   }
 }
 
 function windowsAclController(options) {
   const systemDirectory = windowsSystemDirectory(options);
-  const hostEnvironment = windowsHostEnvironment(systemDirectory, options.env || process.env);
+  const hostEnvironment = windowsHostEnvironment(systemDirectory);
   const whoami = path.win32.join(systemDirectory, 'whoami.exe');
   const powershell = path.win32.join(
     systemDirectory,
@@ -1248,7 +1235,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 target validation failed.');
+        throw new Error('Windows private ACL hardening or verification failed.');
       }
       const env = {
         ...hostEnvironment,
@@ -1266,21 +1253,11 @@ function windowsAclController(options) {
           env,
           input,
         );
-      } 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 },
-        );
+      } catch {
+        throw new Error('Windows private ACL hardening or verification failed.');
       }
       if (output !== WINDOWS_ACL_OK_SENTINEL) {
-        throw new Error('Windows private ACL verification returned an unexpected response.');
+        throw new Error('Windows private ACL hardening or verification failed.');
       }
     } finally {
       input?.fill(0);

package/bin/standard-tools-bootstrap.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { createHash, randomUUID } = require('node:crypto');
+const { randomUUID } = require('node:crypto');
 const fs = require('node:fs');
 const path = require('node:path');
 
@@ -31,9 +31,6 @@ function readCatalogue(packageRoot) {
         || !tool.platforms.every((platform) => platform === 'darwin' || platform === 'win32'))) {
       throw new Error(`Ungueltige Standard-Tool-Plattform: ${name}`);
     }
-    if (tool.autoEnable !== undefined && typeof tool.autoEnable !== 'boolean') {
-      throw new Error(`Ungueltiger Standard-Tool-Autostart: ${name}`);
-    }
     if (tool.owner === 'user-mcp'
       && (!isObject(tool.config) || typeof tool.config.enabled !== 'boolean')) {
       throw new Error(`Standard-Tool braucht einen Aktivierungszustand: ${name}`);
@@ -98,24 +95,10 @@ function recognizedBundledServer(name, current, expected) {
     && /^@upstash\/context7-mcp(?:@[^\s]+)?$/u.test(current.args[1] ?? '');
 }
 
-function migrateBundledTimeouts(name, current, expected) {
+function migrateBundledTool(name, current, expected) {
   if (!recognizedBundledServer(name, current, expected)) return false;
   let changed = false;
-  if (name === 'context7') {
-    if (expected.blunExplicitlyEnabled === true) {
-      if (current.enabled !== true) {
-        current.enabled = true;
-        changed = true;
-      }
-      if (current.blunExplicitlyEnabled !== true) {
-        current.blunExplicitlyEnabled = true;
-        changed = true;
-      }
-    } else if (current.blunExplicitlyEnabled !== true && current.enabled !== false) {
-      current.enabled = false;
-      changed = true;
-    }
-  } else if (current.enabled === false) {
+  if (current.enabled === false && name !== 'blun-language-guard') {
     current.enabled = true;
     changed = true;
   }
@@ -151,16 +134,9 @@ function writeMcpDocument(configPath, document) {
   }
 }
 
-function bundledToolConfig(name, tool, {
-  packageRoot,
-  blunDir,
-  platform,
-  env,
-  forceEnable,
-}) {
+function bundledToolConfig(name, tool, { packageRoot, blunDir, platform, env }) {
   const config = structuredClone(tool.config);
-  config.enabled = forceEnable || tool.autoEnable !== false;
-  if (forceEnable && tool.autoEnable === false) config.blunExplicitlyEnabled = true;
+  config.enabled = true;
   if (name === 'blun-language-guard') {
     config.command = platform === 'win32' ? 'python' : 'python3';
     config.args = [
@@ -209,7 +185,6 @@ function seedStandardTools({
   names,
   platform = process.platform,
   env = process.env,
-  forceEnable = false,
 }) {
   const catalogue = readCatalogue(packageRoot);
   if (!Array.isArray(names) || names.length === 0) {
@@ -240,10 +215,9 @@ function seedStandardTools({
       blunDir,
       platform,
       env,
-      forceEnable,
     });
     if (Object.hasOwn(servers, name)) {
-      if (migrateBundledTimeouts(name, servers[name], expected)) updated.push(name);
+      if (migrateBundledTool(name, servers[name], expected)) updated.push(name);
       continue;
     }
     if (hasEquivalentServer(servers, name, tool)) continue;
@@ -251,102 +225,48 @@ function seedStandardTools({
     added.push(name);
   }
 
-  if (added.length > 0 || updated.length > 0) writeMcpDocument(configPath, { ...document, mcpServers: servers });
+  if (added.length > 0 || updated.length > 0) {
+    writeMcpDocument(configPath, { ...document, mcpServers: servers });
+  }
   return { added, updated, configPath };
 }
 
-
-
-function seedStandardSkills({ packageRoot, blunDir }) {
-  const sourceRoot = path.join(packageRoot, 'standard-skills');
-  const sourceRootStat = fs.lstatSync(sourceRoot);
-  if (!sourceRootStat.isDirectory() || sourceRootStat.isSymbolicLink()) {
-    throw new Error(`Ungueltiges BLUN-Standard-Skill-Verzeichnis: ${sourceRoot}`);
+function seedStandardDesignSkill({ packageRoot, blunDir }) {
+  const sourcePath = path.join(
+    packageRoot,
+    'standard-skills',
+    'blun-app-design-system',
+  );
+  const sourceStat = fs.lstatSync(sourcePath);
+  if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink()) {
+    throw new Error(`Ungueltiger BLUN-Standard-Skill: ${sourcePath}`);
   }
+
   const skillsDir = path.join(blunDir, 'skills');
   ensurePrivateDirectory(skillsDir);
-  const markerPath = path.join(skillsDir, '.blun-standard-skills.json');
-  const installed = [];
-  const updated = [];
-  const destinationPaths = [];
-
-  const entries = fs.readdirSync(sourceRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && !entry.isSymbolicLink())
-    .sort((left, right) => left.name.localeCompare(right.name));
-  const fingerprint = createHash('sha256');
-  const visit = (directory, relative = '') => {
-    for (const entry of fs.readdirSync(directory, { withFileTypes: true })
-      .sort((left, right) => left.name.localeCompare(right.name))) {
-      const sourcePath = path.join(directory, entry.name);
-      const relativePath = path.join(relative, entry.name).replaceAll('\\', '/');
-      if (entry.isSymbolicLink()) throw new Error(`Symlink im BLUN-Standard-Skill: ${sourcePath}`);
-      fingerprint.update(relativePath);
-      if (entry.isDirectory()) visit(sourcePath, relativePath);
-      else if (entry.isFile()) fingerprint.update(fs.readFileSync(sourcePath));
-      else throw new Error(`Ungueltiger Eintrag im BLUN-Standard-Skill: ${sourcePath}`);
-    }
-  };
-  visit(sourceRoot);
-  const sourceFingerprint = fingerprint.digest('hex');
-  let marker = null;
-  try {
-    marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
-  } catch {
-    marker = null;
-  }
-  const allDestinationsExist = entries.every((entry) => {
-    const destinationPath = path.join(skillsDir, entry.name);
-    destinationPaths.push(destinationPath);
-    if (!fs.existsSync(destinationPath)) return false;
-    const stat = fs.lstatSync(destinationPath);
-    return stat.isDirectory() && !stat.isSymbolicLink();
-  });
-  if (marker?.fingerprint === sourceFingerprint && allDestinationsExist) {
-    return { installed, updated, destinationPaths, unchanged: true };
-  }
-  destinationPaths.length = 0;
-
-  for (const entry of entries) {
-    const sourcePath = path.join(sourceRoot, entry.name);
-    const destinationPath = path.join(skillsDir, entry.name);
-    const isInstalled = !fs.existsSync(destinationPath);
-    if (!isInstalled) {
-      const destinationStat = fs.lstatSync(destinationPath);
-      if (!destinationStat.isDirectory() || destinationStat.isSymbolicLink()) {
-        throw new Error(`Ungueltiges Ziel fuer BLUN-Standard-Skill: ${destinationPath}`);
-      }
-    } else {
-      fs.mkdirSync(destinationPath, { mode: 0o700 });
+  const destinationPath = path.join(skillsDir, 'blun-app-design-system');
+  const installed = !fs.existsSync(destinationPath);
+  if (!installed) {
+    const destinationStat = fs.lstatSync(destinationPath);
+    if (!destinationStat.isDirectory() || destinationStat.isSymbolicLink()) {
+      throw new Error(`Ungueltiges Ziel fuer BLUN-Standard-Skill: ${destinationPath}`);
     }
-
-    fs.cpSync(sourcePath, destinationPath, {
-      recursive: true,
-      force: true,
-      errorOnExist: false,
-    });
-    (isInstalled ? installed : updated).push(entry.name);
-    destinationPaths.push(destinationPath);
+  } else {
+    ensurePrivateDirectory(destinationPath);
   }
 
-  fs.writeFileSync(markerPath, `${JSON.stringify({ fingerprint: sourceFingerprint, skills: entries.map((entry) => entry.name) }, null, 2)}\n`, 'utf8');
-  if (process.platform !== 'win32') securePrivateTree(skillsDir);
-  return { installed, updated, destinationPaths, unchanged: false };
-}
-
-function seedStandardDesignSkill(options) {
-  const result = seedStandardSkills(options);
-  const name = 'blun-app-design-system';
-  return {
-    installed: result.installed.includes(name),
-    updated: result.updated.includes(name),
-    destinationPath: path.join(options.blunDir, 'skills', name),
-  };
+  fs.cpSync(sourcePath, destinationPath, {
+    recursive: true,
+    force: true,
+    errorOnExist: false,
+  });
+  securePrivateTree(destinationPath);
+  return { installed, updated: !installed, destinationPath };
 }
 
 module.exports = {
   availableStandardToolNames,
   readCatalogue,
   seedStandardDesignSkill,
-  seedStandardSkills,
   seedStandardTools,
 };

package/bin/turn-thinking-policy.cjs

@@ -36,17 +36,9 @@ function classifyThinkingEffortForTurn(text, originKind) {
   const lower = normalized.toLowerCase();
   if (IDENTITY_CHAT.test(lower) || BOSNIAN_STANDALONE_CHAT.test(lower)) return "off";
   if (STANDALONE_CHAT.test(lower)) return "low";
-  if (
-    STATUS_ONLY_CHECK_IN.test(normalized)
-    && !STATUS_FOLLOW_UP_ACTION.test(normalized)
-    && !EXPLICIT_THINKING_INTENT.test(normalized)
-  ) return "low";
-  if (normalized.length > 180 || String(text ?? "").split(/\r?\n/u).length > 2) return undefined;
-  if (ACTIONABLE_PROMPT.test(normalized) || EXPLICIT_THINKING_INTENT.test(normalized)) return undefined;
-
-  const shortQuestion = /[?]\s*$/u.test(normalized)
-    || /^(?:was|wer|wie|warum|wieso|weshalb|wo|wann|welche?r?s?|what|who|how|why|where|when|which|can you|kannst du)\b/iu.test(normalized);
-  return shortQuestion ? "low" : undefined;
+  // Fast chat drops project context and tools. Brevity or a status question
+  // cannot establish that this evidence is unnecessary.
+  return undefined;
 }
 
 function selectThinkingEffortForTurn(text, originKind, profileEffort) {