@agenshield/daemon 0.7.0 → 0.7.2

package/main.js

@@ -1044,10 +1044,7 @@ PLISTEOF`);
 }
 async function startOpenClawServices() {
   try {
-    try {
-      await execAsync3(`sudo launchctl kickstart system/${OPENCLAW_GATEWAY_LABEL}`);
-    } catch {
-    }
+    await execAsync3(`sudo launchctl kickstart system/${OPENCLAW_GATEWAY_LABEL}`);
     return {
       success: true,
       message: "OpenClaw gateway started"
@@ -1062,10 +1059,7 @@ async function startOpenClawServices() {
 }
 async function stopOpenClawServices() {
   try {
-    try {
-      await execAsync3(`sudo launchctl kill SIGTERM system/${OPENCLAW_GATEWAY_LABEL}`);
-    } catch {
-    }
+    await execAsync3(`sudo launchctl kill SIGTERM system/${OPENCLAW_GATEWAY_LABEL}`);
     return {
       success: true,
       message: "OpenClaw gateway stopped"
@@ -1080,10 +1074,7 @@ async function stopOpenClawServices() {
 }
 async function restartOpenClawServices() {
   try {
-    try {
-      await execAsync3(`sudo launchctl kickstart -k system/${OPENCLAW_GATEWAY_LABEL}`);
-    } catch {
-    }
+    await execAsync3(`sudo launchctl kickstart -k system/${OPENCLAW_GATEWAY_LABEL}`);
     return {
       success: true,
       message: "OpenClaw gateway restarted"
@@ -1166,15 +1157,29 @@ function getOpenClawStatusSync() {
 async function getOpenClawDashboardUrl() {
   try {
     const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-    const agentUsername = path22.basename(agentHome);
-    const { stdout, stderr } = await execAsync3(
-      `sudo -H -u ${agentUsername} ${OPENCLAW_LAUNCHER_PATH} dashboard`,
-      { timeout: 15e3, maxBuffer: 10 * 1024 * 1024 }
-    );
-    const url = stdout.trim();
-    if (!url) {
-      return { success: false, error: stderr.trim() || "No URL returned from openclaw dashboard" };
+    const configPath = path22.join(agentHome, ".openclaw", "openclaw.json");
+    let raw;
+    try {
+      raw = await fs32.readFile(configPath, "utf-8");
+    } catch (err) {
+      if (err.code === "EACCES") {
+        const agentUsername = path22.basename(agentHome);
+        const { stdout } = await execAsync3(
+          `sudo -H -u ${agentUsername} cat "${configPath}"`,
+          { cwd: "/" }
+        );
+        raw = stdout;
+      } else {
+        return { success: false, error: `Cannot read openclaw.json: ${err.message}` };
+      }
+    }
+    const config = JSON.parse(raw);
+    const port = config.gateway?.port;
+    const token = config.gateway?.auth?.token;
+    if (!port || !token) {
+      return { success: false, error: "Gateway port or auth token not found in openclaw.json" };
     }
+    const url = `http://127.0.0.1:${port}/?token=${token}`;
     return { success: true, url };
   } catch (error) {
     return { success: false, error: `Failed to get dashboard URL: ${error.message}` };
@@ -1288,6 +1293,41 @@ var init_crypto = __esm({
   }
 });
 
+// libs/shield-daemon/src/vault/installation-key.ts
+import * as crypto2 from "node:crypto";
+async function getInstallationKey() {
+  if (cachedKey) return cachedKey;
+  const vault = getVault();
+  const contents = await vault.load();
+  if (contents.installationKey) {
+    cachedKey = contents.installationKey;
+    return cachedKey;
+  }
+  const key = crypto2.randomBytes(32).toString("hex");
+  await vault.set("installationKey", key);
+  cachedKey = key;
+  console.log("[InstallationKey] Generated new installation key");
+  return key;
+}
+async function getInstallationTag() {
+  const key = await getInstallationKey();
+  return `${INSTALLATION_KEY_PREFIX}${key}`;
+}
+function hasValidInstallationTagSync(tags) {
+  if (!cachedKey) return false;
+  const fullTag = `${INSTALLATION_KEY_PREFIX}${cachedKey}`;
+  return tags.some((tag) => tag === fullTag);
+}
+var INSTALLATION_KEY_PREFIX, cachedKey;
+var init_installation_key = __esm({
+  "libs/shield-daemon/src/vault/installation-key.ts"() {
+    "use strict";
+    init_vault();
+    INSTALLATION_KEY_PREFIX = "agenshield-";
+    cachedKey = null;
+  }
+});
+
 // libs/shield-daemon/src/vault/index.ts
 import * as fs4 from "node:fs";
 import * as path4 from "node:path";
@@ -1305,6 +1345,7 @@ var init_vault = __esm({
     init_crypto();
     init_paths();
     init_crypto();
+    init_installation_key();
     Vault = class {
       key;
       vaultPath;
@@ -1761,7 +1802,7 @@ var init_secret_sync = __esm({
 });
 
 // libs/shield-daemon/src/main.ts
-import * as fs23 from "node:fs";
+import * as fs24 from "node:fs";
 
 // libs/shield-daemon/src/config/index.ts
 init_paths();
@@ -1769,7 +1810,7 @@ init_defaults();
 init_loader();
 
 // libs/shield-daemon/src/server.ts
-import * as fs21 from "node:fs";
+import * as fs23 from "node:fs";
 import Fastify from "fastify";
 import cors from "@fastify/cors";
 import fastifyStatic from "@fastify/static";
@@ -1842,7 +1883,7 @@ init_state();
 init_vault();
 
 // libs/shield-daemon/src/auth/session.ts
-import * as crypto2 from "node:crypto";
+import * as crypto3 from "node:crypto";
 import { DEFAULT_AUTH_CONFIG } from "@agenshield/ipc";
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
@@ -1856,7 +1897,7 @@ var SessionManager = class {
    * Generate a secure random token
    */
   generateToken() {
-    return crypto2.randomBytes(32).toString("base64url");
+    return crypto3.randomBytes(32).toString("base64url");
   }
   /**
    * Create a new session
@@ -2141,11 +2182,24 @@ function getOpenClawConfigPath() {
   const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
   return path8.join(agentHome, ".openclaw", "openclaw.json");
 }
-function readConfig() {
+function readOpenClawConfig() {
   const configPath = getOpenClawConfigPath();
   try {
     if (fs8.existsSync(configPath)) {
-      return JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+      try {
+        return JSON.parse(fs8.readFileSync(configPath, "utf-8"));
+      } catch (err) {
+        if (err.code === "EACCES") {
+          const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
+          const agentUsername = path8.basename(agentHome);
+          const raw = execSync6(
+            `sudo -H -u ${agentUsername} cat "${configPath}"`,
+            { encoding: "utf-8", cwd: "/", stdio: ["pipe", "pipe", "pipe"] }
+          );
+          return JSON.parse(raw);
+        }
+        throw err;
+      }
     }
   } catch {
     console.warn("[OpenClawConfig] Failed to read openclaw.json, starting fresh");
@@ -2163,7 +2217,7 @@ function writeConfig(config) {
       const agentUsername = path8.basename(agentHome);
       execSync6(
         `sudo -H -u ${agentUsername} tee "${configPath}" > /dev/null`,
-        { input: JSON.stringify(config, null, 2), stdio: ["pipe", "pipe", "pipe"] }
+        { input: JSON.stringify(config, null, 2), stdio: ["pipe", "pipe", "pipe"], cwd: "/" }
       );
     } else {
       throw err;
@@ -2171,27 +2225,30 @@ function writeConfig(config) {
   }
 }
 function addSkillEntry(slug) {
-  const config = readConfig();
+  const config = readOpenClawConfig();
   if (!config.skills) {
     config.skills = {};
   }
   if (!config.skills.entries) {
     config.skills.entries = {};
   }
-  config.skills.entries[slug] = { enabled: true };
+  const existing = config.skills.entries[slug] ?? {};
+  config.skills.entries[slug] = { ...existing, enabled: true };
   writeConfig(config);
   console.log(`[OpenClawConfig] Added skill entry: ${slug}`);
 }
 function removeSkillEntry(slug) {
-  const config = readConfig();
+  const config = readOpenClawConfig();
   if (config.skills?.entries?.[slug]) {
-    delete config.skills.entries[slug];
+    const existing = config.skills.entries[slug];
+    delete existing.env;
+    config.skills.entries[slug] = { ...existing, enabled: false };
     writeConfig(config);
-    console.log(`[OpenClawConfig] Removed skill entry: ${slug}`);
+    console.log(`[OpenClawConfig] Disabled skill entry: ${slug}`);
   }
 }
 function syncOpenClawFromPolicies(policies) {
-  const config = readConfig();
+  const config = readOpenClawConfig();
   if (!config.skills) config.skills = {};
   const allowBundled = [];
   for (const p of policies) {
@@ -2410,7 +2467,7 @@ function generatePolicyMarkdown(policies, knownSkills) {
 // libs/shield-daemon/src/watchers/skills.ts
 import * as fs11 from "node:fs";
 import * as path11 from "node:path";
-import * as crypto3 from "node:crypto";
+import * as crypto4 from "node:crypto";
 import { parseSkillMd } from "@agenshield/sandbox";
 
 // libs/shield-daemon/src/services/marketplace.ts
@@ -2439,35 +2496,35 @@ var ANALYSIS_TIMEOUT = 4 * 6e4;
 var SEARCH_CACHE_TTL = 6e4;
 var DETAIL_CACHE_TTL = 5 * 6e4;
 var SHORT_TIMEOUT = 1e4;
-async function convexAction(path21, args, timeout) {
+async function convexAction(path24, args, timeout) {
   const res = await fetch(`${CONVEX_BASE}/api/action`, {
     method: "POST",
     signal: AbortSignal.timeout(timeout),
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ path: path21, args, format: "json" })
+    body: JSON.stringify({ path: path24, args, format: "json" })
   });
   if (!res.ok) {
-    throw new Error(`Convex action ${path21} returned ${res.status}`);
+    throw new Error(`Convex action ${path24} returned ${res.status}`);
   }
   const body = await res.json();
   if (body.status === "error") {
-    throw new Error(`Convex action ${path21}: ${body.errorMessage ?? "unknown error"}`);
+    throw new Error(`Convex action ${path24}: ${body.errorMessage ?? "unknown error"}`);
   }
   return body.value;
 }
-async function convexQuery(path21, args, timeout) {
+async function convexQuery(path24, args, timeout) {
   const res = await fetch(`${CONVEX_BASE}/api/query`, {
     method: "POST",
     signal: AbortSignal.timeout(timeout),
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ path: path21, args, format: "json" })
+    body: JSON.stringify({ path: path24, args, format: "json" })
   });
   if (!res.ok) {
-    throw new Error(`Convex query ${path21} returned ${res.status}`);
+    throw new Error(`Convex query ${path24} returned ${res.status}`);
   }
   const body = await res.json();
   if (body.status === "error") {
-    throw new Error(`Convex query ${path21}: ${body.errorMessage ?? "unknown error"}`);
+    throw new Error(`Convex query ${path24}: ${body.errorMessage ?? "unknown error"}`);
   }
   return body.value;
 }
@@ -2599,6 +2656,17 @@ function updateDownloadedAnalysis(slug, analysis) {
   } catch {
   }
 }
+function markDownloadedAsInstalled(slug) {
+  const metaPath = path9.join(getMarketplaceDir(), slug, "metadata.json");
+  try {
+    if (!fs9.existsSync(metaPath)) return;
+    const meta = JSON.parse(fs9.readFileSync(metaPath, "utf-8"));
+    if (meta.wasInstalled) return;
+    meta.wasInstalled = true;
+    fs9.writeFileSync(metaPath, JSON.stringify(meta, null, 2), "utf-8");
+  } catch {
+  }
+}
 function listDownloadedSkills() {
   const baseDir = getMarketplaceDir();
   if (!fs9.existsSync(baseDir)) return [];
@@ -2619,7 +2687,8 @@ function listDownloadedSkills() {
           tags: meta.tags ?? [],
           hasAnalysis: !!meta.analysis,
           source: meta.source,
-          analysis: meta.analysis
+          analysis: meta.analysis,
+          wasInstalled: meta.wasInstalled ?? false
         });
       } catch {
       }
@@ -2669,9 +2738,9 @@ function inlineImagesInMarkdown(markdown, files) {
     const mime = isImageExt(file.name);
     if (mime && file.content.startsWith("data:")) {
       imageMap.set(file.name, file.content);
-      const basename3 = file.name.split("/").pop() ?? "";
-      if (basename3 && !imageMap.has(basename3)) {
-        imageMap.set(basename3, file.content);
+      const basename6 = file.name.split("/").pop() ?? "";
+      if (basename6 && !imageMap.has(basename6)) {
+        imageMap.set(basename6, file.content);
       }
     }
   }
@@ -3197,10 +3266,10 @@ function emitSecurityWarning(warning) {
 function emitSecurityCritical(issue) {
   daemonEvents.broadcast("security:critical", { message: issue });
 }
-function emitApiRequest(method, path21, statusCode, duration, requestBody, responseBody) {
+function emitApiRequest(method, path24, statusCode, duration, requestBody, responseBody) {
   daemonEvents.broadcast("api:request", {
     method,
-    path: path21,
+    path: path24,
     statusCode,
     duration,
     ...requestBody !== void 0 && { requestBody },
@@ -3216,6 +3285,9 @@ function emitSkillUntrustedDetected(name, reason) {
 function emitSkillApproved(skillName) {
   daemonEvents.broadcast("skills:approved", { name: skillName });
 }
+function emitExecDenied(command, reason) {
+  daemonEvents.broadcast("exec:denied", { command, reason });
+}
 function emitAgenCoAuthRequired(authUrl, integration) {
   daemonEvents.broadcast("agenco:auth_required", { authUrl, integration });
 }
@@ -3255,6 +3327,56 @@ function emitEvent(type, data) {
 
 // libs/shield-daemon/src/watchers/skills.ts
 init_paths();
+
+// libs/shield-daemon/src/services/skill-tag-injector.ts
+init_installation_key();
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var FRONTMATTER_RE = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+async function injectInstallationTag(content) {
+  const tag = await getInstallationTag();
+  const match = content.match(FRONTMATTER_RE);
+  if (!match) {
+    return `---
+tags:
+  - ${tag}
+---
+${content}`;
+  }
+  try {
+    const metadata = parseYaml(match[1]);
+    if (!metadata || typeof metadata !== "object") {
+      return content;
+    }
+    if (!Array.isArray(metadata.tags)) {
+      metadata.tags = [];
+    }
+    metadata.tags = metadata.tags.filter(
+      (t) => typeof t !== "string" || !t.startsWith("agenshield-")
+    );
+    metadata.tags.push(tag);
+    return `---
+${stringifyYaml(metadata).trimEnd()}
+---
+${match[2]}`;
+  } catch {
+    return content;
+  }
+}
+function extractTagsFromSkillMd(content) {
+  const match = content.match(FRONTMATTER_RE);
+  if (!match) return [];
+  try {
+    const metadata = parseYaml(match[1]);
+    if (!metadata || typeof metadata !== "object") return [];
+    if (!Array.isArray(metadata.tags)) return [];
+    return metadata.tags.filter((t) => typeof t === "string");
+  } catch {
+    return [];
+  }
+}
+
+// libs/shield-daemon/src/watchers/skills.ts
+init_installation_key();
 function getApprovedSkillsPath() {
   return path11.join(getSystemConfigDir(), "approved-skills.json");
 }
@@ -3393,7 +3515,7 @@ function computeSkillHash(skillDir) {
   const files = readSkillFiles(skillDir);
   if (files.length === 0) return null;
   files.sort((a, b) => a.name.localeCompare(b.name));
-  const hash = crypto3.createHash("sha256");
+  const hash = crypto4.createHash("sha256");
   for (const file of files) {
     hash.update(file.name);
     hash.update(file.content);
@@ -3422,10 +3544,33 @@ function scanSkills() {
       const approvedEntry = approvedMap.get(skillName);
       if (!approvedEntry) {
         const fullPath = path11.join(skillsDir, skillName);
-        const slug = moveToMarketplace(skillName, fullPath);
-        if (slug) {
-          if (callbacks.onUntrustedDetected) {
-            callbacks.onUntrustedDetected({ name: skillName, reason: "Skill not in approved list" });
+        let autoApproved = false;
+        for (const mdName of ["SKILL.md", "skill.md"]) {
+          const mdPath = path11.join(fullPath, mdName);
+          try {
+            if (fs11.existsSync(mdPath)) {
+              const content = fs11.readFileSync(mdPath, "utf-8");
+              const tags = extractTagsFromSkillMd(content);
+              if (hasValidInstallationTagSync(tags)) {
+                console.log(`[SkillsWatcher] Auto-approving skill with valid installation tag: ${skillName}`);
+                const hash = computeSkillHash(fullPath);
+                addToApprovedList(skillName, void 0, hash ?? void 0);
+                if (callbacks.onApproved) {
+                  callbacks.onApproved(skillName);
+                }
+                autoApproved = true;
+                break;
+              }
+            }
+          } catch {
+          }
+        }
+        if (!autoApproved) {
+          const slug = moveToMarketplace(skillName, fullPath);
+          if (slug) {
+            if (callbacks.onUntrustedDetected) {
+              callbacks.onUntrustedDetected({ name: skillName, reason: "Skill not in approved list" });
+            }
           }
         }
       } else if (approvedEntry.hash) {
@@ -3455,26 +3600,16 @@ function scanSkills() {
 }
 function detectOpenClawMismatches() {
   try {
-    const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-    const configPath = path11.join(agentHome, ".openclaw", "openclaw.json");
-    if (!fs11.existsSync(configPath)) return;
-    const raw = fs11.readFileSync(configPath, "utf-8");
-    const config = JSON.parse(raw);
-    if (!config.skills?.entries) return;
     const approved = loadApprovedSkills();
     const approvedNames = new Set(approved.map((a) => a.name));
-    const entries = Object.keys(config.skills.entries);
-    let changed = false;
-    for (const name of entries) {
+    const config = readOpenClawConfig();
+    if (!config.skills?.entries) return;
+    for (const name of Object.keys(config.skills.entries)) {
       if (!approvedNames.has(name)) {
-        delete config.skills.entries[name];
-        changed = true;
-        console.log(`[SkillsWatcher] Removed stale openclaw.json entry: ${name}`);
+        removeSkillEntry(name);
+        console.log(`[SkillsWatcher] Disabled stale openclaw.json entry: ${name}`);
       }
     }
-    if (changed) {
-      fs11.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
-    }
   } catch {
   }
 }
@@ -3541,7 +3676,7 @@ function approveSkill(skillName) {
     const cachedFiles = getDownloadedSkillFiles(slug);
     let hash;
     if (cachedFiles.length > 0) {
-      const h = crypto3.createHash("sha256");
+      const h = crypto4.createHash("sha256");
       const sorted = [...cachedFiles].sort((a, b) => a.name.localeCompare(b.name));
       for (const file of sorted) {
         h.update(file.name);
@@ -3610,14 +3745,15 @@ function listApproved() {
 function getSkillsDir() {
   return skillsDir;
 }
-function addToApprovedList(skillName, publisher, hash) {
+function addToApprovedList(skillName, publisher, hash, slug) {
   const approved = loadApprovedSkills();
   if (!approved.some((s) => s.name === skillName)) {
     approved.push({
       name: skillName,
       approvedAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...publisher ? { publisher } : {},
-      ...hash ? { hash } : {}
+      ...hash ? { hash } : {},
+      ...slug ? { slug } : {}
     });
     saveApprovedSkills(approved);
   }
@@ -3864,7 +4000,7 @@ async function securityRoutes(app) {
 // libs/shield-daemon/src/auth/passcode.ts
 init_vault();
 init_state();
-import * as crypto4 from "node:crypto";
+import * as crypto5 from "node:crypto";
 import { DEFAULT_AUTH_CONFIG as DEFAULT_AUTH_CONFIG2 } from "@agenshield/ipc";
 var ITERATIONS = 1e5;
 var KEY_LENGTH = 64;
@@ -3872,8 +4008,8 @@ var DIGEST = "sha512";
 var SALT_LENGTH = 16;
 function hashPasscode(passcode) {
   return new Promise((resolve3, reject) => {
-    const salt = crypto4.randomBytes(SALT_LENGTH);
-    crypto4.pbkdf2(passcode, salt, ITERATIONS, KEY_LENGTH, DIGEST, (err, derivedKey) => {
+    const salt = crypto5.randomBytes(SALT_LENGTH);
+    crypto5.pbkdf2(passcode, salt, ITERATIONS, KEY_LENGTH, DIGEST, (err, derivedKey) => {
       if (err) {
         reject(err);
         return;
@@ -3893,12 +4029,12 @@ function verifyPasscode(passcode, storedHash) {
     const iterations = parseInt(parts[0], 10);
     const salt = Buffer.from(parts[1], "base64");
     const hash = Buffer.from(parts[2], "base64");
-    crypto4.pbkdf2(passcode, salt, iterations, hash.length, DIGEST, (err, derivedKey) => {
+    crypto5.pbkdf2(passcode, salt, iterations, hash.length, DIGEST, (err, derivedKey) => {
       if (err) {
         reject(err);
         return;
       }
-      resolve3(crypto4.timingSafeEqual(hash, derivedKey));
+      resolve3(crypto5.timingSafeEqual(hash, derivedKey));
     });
   });
 }
@@ -4030,16 +4166,16 @@ var PROTECTED_ROUTES = [
   { method: "POST", path: "/api/skills/install" },
   { method: "GET", path: "/api/openclaw/dashboard-url" }
 ];
-function isProtectedRoute(method, path21) {
+function isProtectedRoute(method, path24) {
   return PROTECTED_ROUTES.some(
-    (route) => route.method === method && path21.startsWith(route.path)
+    (route) => route.method === method && path24.startsWith(route.path)
   );
 }
 function createAuthHook() {
   return async (request2, reply) => {
     const method = request2.method;
-    const path21 = request2.url.split("?")[0];
-    if (!isProtectedRoute(method, path21)) {
+    const path24 = request2.url.split("?")[0];
+    if (!isProtectedRoute(method, path24)) {
       return;
     }
     if (!isAuthenticated(request2)) {
@@ -4070,6 +4206,12 @@ data: ${data}
 
 `;
 }
+var ALWAYS_FULL_PREFIXES = ["skills:", "exec:", "interceptor:", "security:", "wrappers:", "process:", "config:"];
+function shouldSendFull(event, authenticated) {
+  if (authenticated) return true;
+  if (event.type === "heartbeat" || event.type === "daemon:status") return true;
+  return ALWAYS_FULL_PREFIXES.some((p) => event.type.startsWith(p));
+}
 async function sseRoutes(app) {
   app.get("/sse/events", async (request2, reply) => {
     const authenticated = isAuthenticated(request2);
@@ -4095,7 +4237,7 @@ async function sseRoutes(app) {
     reply.raw.write(authenticated ? formatSSE(statusEvent) : formatStrippedSSE(statusEvent));
     const unsubscribe = daemonEvents.subscribe((event) => {
       try {
-        if (event.type === "heartbeat" || event.type === "daemon:status" || event.type.startsWith("skills:") || authenticated) {
+        if (shouldSendFull(event, authenticated)) {
           reply.raw.write(formatSSE(event));
         } else {
           reply.raw.write(formatStrippedSSE(event));
@@ -4143,7 +4285,7 @@ async function sseRoutes(app) {
     const unsubscribe = daemonEvents.subscribe((event) => {
       if (event.type.startsWith(filter) || event.type === "heartbeat" || event.type === "daemon:status") {
         try {
-          if (event.type === "heartbeat" || event.type === "daemon:status" || authenticated) {
+          if (shouldSendFull(event, authenticated)) {
             reply.raw.write(formatSSE(event));
           } else {
             reply.raw.write(formatStrippedSSE(event));
@@ -7538,19 +7680,50 @@ async function agencoRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/skills.ts
-import * as fs16 from "node:fs";
-import * as path16 from "node:path";
+import * as fs17 from "node:fs";
+import * as path17 from "node:path";
 import { execSync as execSync9 } from "node:child_process";
-import { parseSkillMd as parseSkillMd2 } from "@agenshield/sandbox";
+import { parseSkillMd as parseSkillMd3, stripEnvFromSkillMd as stripEnvFromSkillMd2 } from "@agenshield/sandbox";
 
 // libs/shield-daemon/src/services/skill-lifecycle.ts
 import * as fs14 from "node:fs";
 import * as path14 from "node:path";
 import { execSync as execSync8 } from "node:child_process";
-function createSkillWrapper(name, binDir) {
-  if (!fs14.existsSync(binDir)) {
-    fs14.mkdirSync(binDir, { recursive: true });
+function sudoMkdir(dir, agentUsername) {
+  try {
+    fs14.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    if (err.code === "EACCES") {
+      execSync8(`sudo -H -u ${agentUsername} /bin/mkdir -p "${dir}"`, { cwd: "/", stdio: "pipe" });
+    } else {
+      throw err;
+    }
+  }
+}
+function sudoWriteFile(filePath, content, agentUsername, mode) {
+  try {
+    fs14.writeFileSync(filePath, content, { mode });
+  } catch (err) {
+    if (err.code === "EACCES") {
+      execSync8(
+        `sudo -H -u ${agentUsername} tee "${filePath}" > /dev/null`,
+        { input: content, cwd: "/", stdio: ["pipe", "pipe", "pipe"] }
+      );
+      if (mode) {
+        try {
+          execSync8(`sudo -H -u ${agentUsername} chmod ${mode.toString(8)} "${filePath}"`, { cwd: "/", stdio: "pipe" });
+        } catch {
+        }
+      }
+    } else {
+      throw err;
+    }
   }
+}
+function createSkillWrapper(name, binDir) {
+  const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
+  const agentUsername = path14.basename(agentHome);
+  sudoMkdir(binDir, agentUsername);
   const wrapperPath = path14.join(binDir, name);
   const wrapperContent = `#!/bin/bash
 # ${name} skill wrapper - policy-enforced execution
@@ -7558,7 +7731,7 @@ function createSkillWrapper(name, binDir) {
 if ! /bin/pwd > /dev/null 2>&1; then cd ~ 2>/dev/null || cd /; fi
 exec /opt/agenshield/bin/shield-client skill run "${name}" "$@"
 `;
-  fs14.writeFileSync(wrapperPath, wrapperContent, { mode: 493 });
+  sudoWriteFile(wrapperPath, wrapperContent, agentUsername, 493);
   const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
   try {
     execSync8(`chown root:${socketGroup} "${wrapperPath}"`, { stdio: "pipe" });
@@ -7603,8 +7776,8 @@ function removeSkillPolicy(name) {
 }
 
 // libs/shield-daemon/src/routes/marketplace.ts
-import * as fs15 from "node:fs";
-import * as path15 from "node:path";
+import * as fs16 from "node:fs";
+import * as path16 from "node:path";
 
 // libs/shield-broker/dist/index.js
 import { exec as exec4 } from "node:child_process";
@@ -7880,6 +8053,176 @@ async function uninstallSkillViaBroker(slug, options = {}) {
   return result;
 }
 
+// libs/shield-daemon/src/routes/marketplace.ts
+import { stripEnvFromSkillMd } from "@agenshield/sandbox";
+
+// libs/shield-daemon/src/services/skill-deps.ts
+import * as fs15 from "node:fs";
+import * as path15 from "node:path";
+import { parseSkillMd as parseSkillMd2, extractSkillInfo } from "@agenshield/sandbox";
+import { execWithProgress as execWithProgress3 } from "@agenshield/sandbox";
+var SUPPORTED_KINDS = /* @__PURE__ */ new Set(["brew", "npm", "pip"]);
+var SAFE_PACKAGE_RE = /^[a-zA-Z0-9@/_.\-]+$/;
+var SYSTEM_PATH = "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+function findSkillMdRecursive(dir, depth = 0) {
+  if (depth > 3) return null;
+  try {
+    for (const name of ["SKILL.md", "skill.md", "README.md", "readme.md"]) {
+      const candidate = path15.join(dir, name);
+      if (fs15.existsSync(candidate)) return candidate;
+    }
+    const entries = fs15.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const found = findSkillMdRecursive(path15.join(dir, entry.name), depth + 1);
+      if (found) return found;
+    }
+  } catch {
+  }
+  return null;
+}
+async function executeSkillInstallSteps(options) {
+  const { slug, skillDir, agentHome, agentUsername, onLog } = options;
+  const installed = [];
+  const errors = [];
+  const skillMdPath = findSkillMdRecursive(skillDir);
+  if (!skillMdPath) {
+    return { success: true, installed, errors };
+  }
+  let content;
+  try {
+    content = fs15.readFileSync(skillMdPath, "utf-8");
+  } catch {
+    return { success: true, installed, errors };
+  }
+  const parsed = parseSkillMd2(content);
+  if (!parsed) {
+    return { success: true, installed, errors };
+  }
+  const info = extractSkillInfo(parsed.metadata);
+  const installSteps = info.installSteps;
+  if (!Array.isArray(installSteps) || installSteps.length === 0) {
+    return { success: true, installed, errors };
+  }
+  onLog(`Found ${installSteps.length} dependency install step(s) for ${slug}`);
+  for (const step of installSteps) {
+    const kind = step.kind;
+    const stepId = step.id || kind;
+    if (!SUPPORTED_KINDS.has(kind)) {
+      errors.push(`Unsupported install kind "${kind}" (step: ${stepId})`);
+      continue;
+    }
+    try {
+      switch (kind) {
+        case "brew": {
+          const formula = step.formula;
+          if (!formula) {
+            errors.push(`Brew step "${stepId}" missing formula`);
+            break;
+          }
+          if (!SAFE_PACKAGE_RE.test(formula)) {
+            errors.push(`Unsafe brew formula name: ${formula}`);
+            break;
+          }
+          onLog(`Installing brew formula: ${formula}`);
+          const brewCmd = [
+            `export HOME="${agentHome}"`,
+            `export PATH="${agentHome}/homebrew/bin:${agentHome}/bin:${SYSTEM_PATH}:$PATH"`,
+            `brew install ${formula}`
+          ].join(" && ");
+          await execWithProgress3(
+            `sudo -H -u ${agentUsername} /bin/bash --norc --noprofile -c '${brewCmd}'`,
+            onLog,
+            { timeout: 12e4, cwd: "/" }
+          );
+          installed.push(formula);
+          break;
+        }
+        case "npm": {
+          const pkg = step["package"];
+          if (!pkg) {
+            errors.push(`npm step "${stepId}" missing package`);
+            break;
+          }
+          if (!SAFE_PACKAGE_RE.test(pkg)) {
+            errors.push(`Unsafe npm package name: ${pkg}`);
+            break;
+          }
+          onLog(`Installing npm package: ${pkg}`);
+          const npmCmd = [
+            `export HOME="${agentHome}"`,
+            `export PATH="${agentHome}/bin:${SYSTEM_PATH}:$PATH"`,
+            `source "${agentHome}/.nvm/nvm.sh" 2>/dev/null || true`,
+            `npm install -g ${pkg}`
+          ].join(" && ");
+          await execWithProgress3(
+            `sudo -H -u ${agentUsername} /bin/bash --norc --noprofile -c '${npmCmd}'`,
+            onLog,
+            { timeout: 6e4, cwd: "/" }
+          );
+          installed.push(pkg);
+          break;
+        }
+        case "pip": {
+          const pkg = step["package"];
+          if (!pkg) {
+            errors.push(`pip step "${stepId}" missing package`);
+            break;
+          }
+          if (!SAFE_PACKAGE_RE.test(pkg)) {
+            errors.push(`Unsafe pip package name: ${pkg}`);
+            break;
+          }
+          onLog(`Installing pip package: ${pkg}`);
+          const pipCmd = [
+            `export HOME="${agentHome}"`,
+            `export PATH="${agentHome}/bin:${SYSTEM_PATH}:$PATH"`,
+            `pip install ${pkg}`
+          ].join(" && ");
+          await execWithProgress3(
+            `sudo -H -u ${agentUsername} /bin/bash --norc --noprofile -c '${pipCmd}'`,
+            onLog,
+            { timeout: 6e4, cwd: "/" }
+          );
+          installed.push(pkg);
+          break;
+        }
+      }
+    } catch (err) {
+      const msg = `Failed to install ${kind} dep (step: ${stepId}): ${err.message}`;
+      onLog(msg);
+      errors.push(msg);
+    }
+  }
+  const requiredBins = info.bins;
+  if (requiredBins.length > 0) {
+    onLog(`Verifying required binaries: ${requiredBins.join(", ")}`);
+    for (const bin of requiredBins) {
+      try {
+        const checkCmd = [
+          `export HOME="${agentHome}"`,
+          `export PATH="${agentHome}/homebrew/bin:${agentHome}/bin:${SYSTEM_PATH}:$PATH"`,
+          `source "${agentHome}/.nvm/nvm.sh" 2>/dev/null || true`,
+          `which ${bin}`
+        ].join(" && ");
+        await execWithProgress3(
+          `sudo -H -u ${agentUsername} /bin/bash --norc --noprofile -c '${checkCmd}'`,
+          () => {
+          },
+          { timeout: 5e3, cwd: "/" }
+        );
+      } catch {
+        errors.push(`Required binary "${bin}" not found in agent PATH after install`);
+      }
+    }
+  }
+  return {
+    success: errors.length === 0,
+    installed,
+    errors
+  };
+}
+
 // libs/shield-daemon/src/routes/marketplace.ts
 var installInProgress = /* @__PURE__ */ new Set();
 function isInstallInProgress(slug) {
@@ -8134,7 +8477,7 @@ async function marketplaceRoutes(app) {
               error: "Critical vulnerability detected",
               analysis: analysisResult
             });
-            return { success: false, name: slug, analysis: analysisResult, logs };
+            return { success: false, name: slug, analysis: analysisResult, logs, depsSuccess: void 0 };
           }
           emitSkillInstallProgress(slug, "download", "Downloading skill files");
           const skill = await getMarketplaceSkill(slug);
@@ -8144,7 +8487,7 @@ async function marketplaceRoutes(app) {
               name: slug,
               error: "No files available for installation"
             });
-            return { success: false, name: slug, analysis: analysisResult, logs };
+            return { success: false, name: slug, analysis: analysisResult, logs, depsSuccess: void 0 };
           }
           const publisher = skill.author;
           logs.push("Downloaded skill files");
@@ -8153,18 +8496,27 @@ async function marketplaceRoutes(app) {
             throw new Error("Skills directory not configured");
           }
           const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-          const binDir = path15.join(agentHome, "bin");
+          const agentUsername = path16.basename(agentHome);
+          const binDir = path16.join(agentHome, "bin");
           const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
-          skillDir = path15.join(skillsDir2, slug);
+          skillDir = path16.join(skillsDir2, slug);
           emitSkillInstallProgress(slug, "approve", "Pre-approving skill");
-          addToApprovedList(slug, publisher);
+          addToApprovedList(slug, publisher, void 0, slug);
           logs.push("Skill pre-approved");
           emitSkillInstallProgress(slug, "copy", "Writing skill files");
+          const taggedFiles = await Promise.all(files.map(async (f) => {
+            let content = f.content;
+            if (/SKILL\.md$/i.test(f.name)) {
+              content = stripEnvFromSkillMd(content);
+              content = await injectInstallationTag(content);
+            }
+            return { ...f, content };
+          }));
           const brokerAvailable = await isBrokerAvailable();
           if (brokerAvailable) {
             const brokerResult = await installSkillViaBroker(
               slug,
-              files.map((f) => ({ name: f.name, content: f.content })),
+              taggedFiles.map((f) => ({ name: f.name, content: f.content })),
               { createWrapper: true, agentHome, socketGroup }
             );
             if (!brokerResult.installed) {
@@ -8183,18 +8535,65 @@ async function marketplaceRoutes(app) {
             }
           } else {
             console.log(`[Marketplace] Broker unavailable, installing ${slug} directly`);
-            fs15.mkdirSync(skillDir, { recursive: true });
-            for (const file of files) {
-              const filePath = path15.join(skillDir, file.name);
-              const fileDir = path15.dirname(filePath);
+            sudoMkdir(skillDir, agentUsername);
+            for (const file of taggedFiles) {
+              const filePath = path16.join(skillDir, file.name);
+              const fileDir = path16.dirname(filePath);
               if (fileDir !== skillDir) {
-                fs15.mkdirSync(fileDir, { recursive: true });
+                sudoMkdir(fileDir, agentUsername);
               }
-              fs15.writeFileSync(filePath, file.content, "utf-8");
+              sudoWriteFile(filePath, file.content, agentUsername);
             }
             createSkillWrapper(slug, binDir);
-            logs.push(`Files written directly: ${files.length} files`);
-            logs.push(`Wrapper created: ${path15.join(binDir, slug)}`);
+            logs.push(`Files written directly: ${taggedFiles.length} files`);
+            logs.push(`Wrapper created: ${path16.join(binDir, slug)}`);
+          }
+          let depsSuccess = true;
+          emitSkillInstallProgress(slug, "deps", "Installing skill dependencies");
+          try {
+            let depsLineCount = 0;
+            let depsLastEmit = Date.now();
+            let depsLastLine = "";
+            const DEPS_DEBOUNCE_MS = 3e3;
+            const depsOnLog = (msg) => {
+              depsLineCount++;
+              depsLastLine = msg;
+              if (/^(Installing|Found|Verifying)\s/.test(msg)) {
+                emitSkillInstallProgress(slug, "deps", msg);
+                depsLastEmit = Date.now();
+                return;
+              }
+              const now = Date.now();
+              if (now - depsLastEmit >= DEPS_DEBOUNCE_MS) {
+                emitSkillInstallProgress(slug, "deps", `Installing... (${depsLineCount} lines)`);
+                depsLastEmit = now;
+              }
+            };
+            const depsResult = await executeSkillInstallSteps({
+              slug,
+              skillDir,
+              agentHome,
+              agentUsername,
+              onLog: depsOnLog
+            });
+            if (depsLineCount > 0) {
+              emitSkillInstallProgress(slug, "deps", `Dependency install complete (${depsLineCount} lines processed)`);
+            }
+            if (depsResult.installed.length > 0) {
+              logs.push(`Dependencies installed: ${depsResult.installed.join(", ")}`);
+            }
+            if (depsResult.errors.length > 0) {
+              depsSuccess = false;
+              for (const err of depsResult.errors) {
+                emitSkillInstallProgress(slug, "warning", `Dependency warning: ${err}`);
+                logs.push(`Dependency warning: ${err}`);
+              }
+            }
+          } catch (err) {
+            depsSuccess = false;
+            const msg = `Dependency installation failed: ${err.message}`;
+            emitSkillInstallProgress(slug, "warning", msg);
+            logs.push(msg);
           }
           addSkillEntry(slug);
           addSkillPolicy(slug);
@@ -8205,14 +8604,19 @@ async function marketplaceRoutes(app) {
             updateApprovedHash(slug, hash);
             logs.push("Integrity hash recorded");
           }
+          try {
+            markDownloadedAsInstalled(slug);
+          } catch {
+          }
           installInProgress.delete(slug);
-          daemonEvents.broadcast("skills:installed", { name: slug, analysis: analysisResult });
+          const depsWarnings = depsSuccess ? void 0 : logs.filter((l) => l.startsWith("Dependency"));
+          daemonEvents.broadcast("skills:installed", { name: slug, analysis: analysisResult, depsWarnings });
           logs.push("Installation complete");
-          return { success: true, name: slug, analysis: analysisResult, logs };
+          return { success: true, name: slug, analysis: analysisResult, logs, depsSuccess };
         } catch (err) {
           try {
-            if (skillDir && fs15.existsSync(skillDir)) {
-              fs15.rmSync(skillDir, { recursive: true, force: true });
+            if (skillDir && fs16.existsSync(skillDir)) {
+              fs16.rmSync(skillDir, { recursive: true, force: true });
             }
             removeFromApprovedList(slug);
           } catch {
@@ -8221,7 +8625,7 @@ async function marketplaceRoutes(app) {
           installInProgress.delete(slug);
           daemonEvents.broadcast("skills:install_failed", { name: slug, error: errorMsg });
           console.error("[Marketplace] Install failed:", errorMsg);
-          return { success: false, name: slug, analysis: analysisResult, logs: [...logs, `Error: ${errorMsg}`] };
+          return { success: false, name: slug, analysis: analysisResult, logs: [...logs, `Error: ${errorMsg}`], depsSuccess: void 0 };
         } finally {
           installInProgress.delete(slug);
         }
@@ -8245,17 +8649,17 @@ async function marketplaceRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/skills.ts
-function findSkillMdRecursive(dir, depth = 0) {
+function findSkillMdRecursive2(dir, depth = 0) {
   if (depth > 3) return null;
   try {
     for (const name of ["SKILL.md", "skill.md", "README.md", "readme.md"]) {
-      const candidate = path16.join(dir, name);
-      if (fs16.existsSync(candidate)) return candidate;
+      const candidate = path17.join(dir, name);
+      if (fs17.existsSync(candidate)) return candidate;
     }
-    const entries = fs16.readdirSync(dir, { withFileTypes: true });
+    const entries = fs17.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const found = findSkillMdRecursive(path16.join(dir, entry.name), depth + 1);
+      const found = findSkillMdRecursive2(path17.join(dir, entry.name), depth + 1);
       if (found) return found;
     }
   } catch {
@@ -8264,10 +8668,10 @@ function findSkillMdRecursive(dir, depth = 0) {
 }
 function readSkillMetadata(skillDir) {
   try {
-    const mdPath = findSkillMdRecursive(skillDir);
+    const mdPath = findSkillMdRecursive2(skillDir);
     if (!mdPath) return {};
-    const content = fs16.readFileSync(mdPath, "utf-8");
-    const parsed = parseSkillMd2(content);
+    const content = fs17.readFileSync(mdPath, "utf-8");
+    const parsed = parseSkillMd3(content);
     const meta = parsed?.metadata;
     return {
       description: meta?.description,
@@ -8325,7 +8729,7 @@ async function skillsRoutes(app) {
     let onDiskNames = [];
     if (skillsDir2) {
       try {
-        onDiskNames = fs16.readdirSync(skillsDir2, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        onDiskNames = fs17.readdirSync(skillsDir2, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
       } catch {
       }
     }
@@ -8335,14 +8739,14 @@ async function skillsRoutes(app) {
     const data = [
       // Approved → active (with metadata from SKILL.md + cached analysis)
       ...approved.map((a) => {
-        const meta = skillsDir2 ? readSkillMetadata(path16.join(skillsDir2, a.name)) : {};
+        const meta = skillsDir2 ? readSkillMetadata(path17.join(skillsDir2, a.name)) : {};
         const cached = getCachedAnalysis2(a.name);
         const dlMeta = getDownloadedSkillMeta(a.name);
         return {
           name: a.name,
           source: "user",
           status: "active",
-          path: path16.join(skillsDir2 ?? "", a.name),
+          path: path17.join(skillsDir2 ?? "", a.name),
           publisher: a.publisher,
           description: meta.description,
           version: meta.version,
@@ -8369,19 +8773,42 @@ async function skillsRoutes(app) {
       }),
       // Workspace: on disk but not approved or untrusted
       ...workspaceNames.map((name) => {
-        const meta = skillsDir2 ? readSkillMetadata(path16.join(skillsDir2, name)) : {};
+        const meta = skillsDir2 ? readSkillMetadata(path17.join(skillsDir2, name)) : {};
         return {
           name,
           source: "workspace",
           status: "workspace",
-          path: path16.join(skillsDir2 ?? "", name),
+          path: path17.join(skillsDir2 ?? "", name),
           description: meta.description,
           version: meta.version,
           author: meta.author,
           tags: meta.tags,
           analysis: buildAnalysisSummary(name, getCachedAnalysis2(name))
         };
-      })
+      }),
+      // Disabled: previously installed marketplace skills that are no longer active
+      ...(() => {
+        const allKnown = /* @__PURE__ */ new Set([
+          ...approvedNames,
+          ...untrustedNames,
+          ...workspaceNames
+        ]);
+        return listDownloadedSkills().filter((d) => d.wasInstalled && !allKnown.has(d.slug) && !allKnown.has(d.name)).map((d) => {
+          const cached = getCachedAnalysis2(d.slug) || getCachedAnalysis2(d.name);
+          return {
+            name: d.slug,
+            source: "marketplace",
+            status: "disabled",
+            path: "",
+            publisher: d.author,
+            description: d.description,
+            version: d.version,
+            author: d.author,
+            tags: d.tags,
+            analysis: buildAnalysisSummary(d.slug, d.analysis || cached)
+          };
+        });
+      })()
     ];
     return reply.send({ data });
   });
@@ -8405,7 +8832,7 @@ async function skillsRoutes(app) {
       let isWorkspace = false;
       if (!entry && !uEntry && skillsDir2) {
         try {
-          isWorkspace = fs16.existsSync(path16.join(skillsDir2, name));
+          isWorkspace = fs17.existsSync(path17.join(skillsDir2, name));
         } catch {
         }
       }
@@ -8423,13 +8850,13 @@ async function skillsRoutes(app) {
           analysis: buildFullAnalysis(name, dlMeta?.analysis || getCachedAnalysis2(name))
         };
       } else if (entry) {
-        const meta = skillsDir2 ? readSkillMetadata(path16.join(skillsDir2, name)) : {};
+        const meta = skillsDir2 ? readSkillMetadata(path17.join(skillsDir2, name)) : {};
         const cached = getCachedAnalysis2(name);
         summary = {
           name,
           source: "user",
           status: "active",
-          path: skillsDir2 ? path16.join(skillsDir2, name) : "",
+          path: skillsDir2 ? path17.join(skillsDir2, name) : "",
           publisher: entry.publisher,
           description: meta.description,
           version: meta.version,
@@ -8438,12 +8865,12 @@ async function skillsRoutes(app) {
           analysis: buildFullAnalysis(name, dlMeta?.analysis || cached)
         };
       } else if (isWorkspace) {
-        const meta = skillsDir2 ? readSkillMetadata(path16.join(skillsDir2, name)) : {};
+        const meta = skillsDir2 ? readSkillMetadata(path17.join(skillsDir2, name)) : {};
         summary = {
           name,
           source: "workspace",
           status: "workspace",
-          path: skillsDir2 ? path16.join(skillsDir2, name) : "",
+          path: skillsDir2 ? path17.join(skillsDir2, name) : "",
           description: meta.description,
           version: meta.version,
           author: meta.author,
@@ -8455,7 +8882,7 @@ async function skillsRoutes(app) {
         summary = {
           name: dlMeta.slug ?? name,
           source: "marketplace",
-          status: "downloaded",
+          status: dlMeta.wasInstalled ? "disabled" : "downloaded",
           description: dlMeta.description,
           path: "",
           publisher: dlMeta.author,
@@ -8468,11 +8895,11 @@ async function skillsRoutes(app) {
         return reply.code(404).send({ error: `Skill "${name}" not found` });
       }
       let content = "";
-      const dirToRead = summary.path || (skillsDir2 ? path16.join(skillsDir2, name) : "");
+      const dirToRead = summary.path || (skillsDir2 ? path17.join(skillsDir2, name) : "");
       if (dirToRead) {
         try {
-          const mdPath = findSkillMdRecursive(dirToRead);
-          if (mdPath) content = fs16.readFileSync(mdPath, "utf-8");
+          const mdPath = findSkillMdRecursive2(dirToRead);
+          if (mdPath) content = fs17.readFileSync(mdPath, "utf-8");
         } catch {
         }
       }
@@ -8510,14 +8937,14 @@ async function skillsRoutes(app) {
       if (!content) {
         const skillsDir2 = getSkillsDir();
         const possibleDirs = [
-          skillsDir2 ? path16.join(skillsDir2, name) : null
+          skillsDir2 ? path17.join(skillsDir2, name) : null
         ].filter(Boolean);
         for (const dir of possibleDirs) {
           try {
-            const mdPath = findSkillMdRecursive(dir);
+            const mdPath = findSkillMdRecursive2(dir);
             if (mdPath) {
-              content = fs16.readFileSync(mdPath, "utf-8");
-              const parsed = parseSkillMd2(content);
+              content = fs17.readFileSync(mdPath, "utf-8");
+              const parsed = parseSkillMd3(content);
               if (parsed?.metadata && !metadata) {
                 metadata = parsed.metadata;
               }
@@ -8532,7 +8959,7 @@ async function skillsRoutes(app) {
             const skillFile = localFiles.find((f) => /skill\.md/i.test(f.name));
             if (skillFile?.content) {
               content = skillFile.content;
-              const parsed = parseSkillMd2(content);
+              const parsed = parseSkillMd3(content);
               if (parsed?.metadata && !metadata) {
                 metadata = parsed.metadata;
               }
@@ -8547,7 +8974,7 @@ async function skillsRoutes(app) {
             const skillFile = freshFiles.find((f) => /skill\.md/i.test(f.name));
             if (skillFile?.content) {
               content = skillFile.content;
-              const parsed = parseSkillMd2(content);
+              const parsed = parseSkillMd3(content);
               if (parsed?.metadata && !metadata) {
                 metadata = parsed.metadata;
               }
@@ -8701,10 +9128,10 @@ async function skillsRoutes(app) {
         return reply.code(500).send({ error: "Skills directory not configured" });
       }
       const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-      const binDir = path16.join(agentHome, "bin");
+      const binDir = path17.join(agentHome, "bin");
       const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
-      const skillDir = path16.join(skillsDir2, name);
-      const isInstalled = fs16.existsSync(skillDir);
+      const skillDir = path17.join(skillsDir2, name);
+      const isInstalled = fs17.existsSync(skillDir);
       if (isInstalled) {
         try {
           const brokerAvailable = await isBrokerAvailable();
@@ -8714,7 +9141,7 @@ async function skillsRoutes(app) {
               agentHome
             });
           } else {
-            fs16.rmSync(skillDir, { recursive: true, force: true });
+            fs17.rmSync(skillDir, { recursive: true, force: true });
             removeSkillWrapper(name, binDir);
           }
           removeSkillEntry(name);
@@ -8722,7 +9149,7 @@ async function skillsRoutes(app) {
           syncOpenClawFromPolicies(loadConfig().policies);
           removeFromApprovedList(name);
           try {
-            deleteDownloadedSkill(name);
+            markDownloadedAsInstalled(name);
           } catch {
           }
           console.log(`[Skills] Disabled marketplace skill: ${name}`);
@@ -8742,12 +9169,20 @@ async function skillsRoutes(app) {
           return reply.code(404).send({ error: "No files in download cache for this skill" });
         }
         try {
-          addToApprovedList(name, meta.author);
+          addToApprovedList(name, meta.author, void 0, meta.slug);
+          const taggedFiles = await Promise.all(files.map(async (f) => {
+            let content = f.content;
+            if (/SKILL\.md$/i.test(f.name)) {
+              content = stripEnvFromSkillMd2(content);
+              content = await injectInstallationTag(content);
+            }
+            return { name: f.name, content, type: f.type };
+          }));
           const brokerAvailable = await isBrokerAvailable();
           if (brokerAvailable) {
             const brokerResult = await installSkillViaBroker(
               name,
-              files.map((f) => ({ name: f.name, content: f.content })),
+              taggedFiles.map((f) => ({ name: f.name, content: f.content })),
               { createWrapper: true, agentHome, socketGroup }
             );
             if (!brokerResult.installed) {
@@ -8759,11 +9194,11 @@ async function skillsRoutes(app) {
               }
             }
           } else {
-            fs16.mkdirSync(skillDir, { recursive: true });
-            for (const file of files) {
-              const filePath = path16.join(skillDir, file.name);
-              fs16.mkdirSync(path16.dirname(filePath), { recursive: true });
-              fs16.writeFileSync(filePath, file.content, "utf-8");
+            fs17.mkdirSync(skillDir, { recursive: true });
+            for (const file of taggedFiles) {
+              const filePath = path17.join(skillDir, file.name);
+              fs17.mkdirSync(path17.dirname(filePath), { recursive: true });
+              fs17.writeFileSync(filePath, file.content, "utf-8");
             }
             try {
               execSync9(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
@@ -8777,12 +9212,16 @@ async function skillsRoutes(app) {
           syncOpenClawFromPolicies(loadConfig().policies);
           const hash = computeSkillHash(skillDir);
           if (hash) updateApprovedHash(name, hash);
+          try {
+            markDownloadedAsInstalled(name);
+          } catch {
+          }
           console.log(`[Skills] Enabled marketplace skill: ${name}`);
           return reply.send({ success: true, action: "enabled", name });
         } catch (err) {
           try {
-            if (fs16.existsSync(skillDir)) {
-              fs16.rmSync(skillDir, { recursive: true, force: true });
+            if (fs17.existsSync(skillDir)) {
+              fs17.rmSync(skillDir, { recursive: true, force: true });
             }
             removeFromApprovedList(name);
           } catch {
@@ -8808,7 +9247,7 @@ async function skillsRoutes(app) {
       const skillMdFile = files.find((f) => f.name === "SKILL.md");
       let metadata;
       if (skillMdFile) {
-        const parsed = parseSkillMd2(skillMdFile.content);
+        const parsed = parseSkillMd3(skillMdFile.content);
         metadata = parsed?.metadata;
       }
       const analysis = analyzeSkill(name, combinedContent, metadata);
@@ -8820,16 +9259,25 @@ async function skillsRoutes(app) {
         return reply.code(500).send({ error: "Skills directory not configured" });
       }
       const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-      const binDir = path16.join(agentHome, "bin");
+      const agentUsername = path17.basename(agentHome);
+      const binDir = path17.join(agentHome, "bin");
       const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
-      const skillDir = path16.join(skillsDir2, name);
+      const skillDir = path17.join(skillsDir2, name);
       try {
         addToApprovedList(name, publisher);
-        fs16.mkdirSync(skillDir, { recursive: true });
-        for (const file of files) {
-          const filePath = path16.join(skillDir, file.name);
-          fs16.mkdirSync(path16.dirname(filePath), { recursive: true });
-          fs16.writeFileSync(filePath, file.content, "utf-8");
+        const taggedFiles = await Promise.all(files.map(async (f) => {
+          let content = f.content;
+          if (/SKILL\.md$/i.test(f.name)) {
+            content = stripEnvFromSkillMd2(content);
+            content = await injectInstallationTag(content);
+          }
+          return { name: f.name, content };
+        }));
+        sudoMkdir(skillDir, agentUsername);
+        for (const file of taggedFiles) {
+          const filePath = path17.join(skillDir, file.name);
+          sudoMkdir(path17.dirname(filePath), agentUsername);
+          sudoWriteFile(filePath, file.content, agentUsername);
         }
         try {
           execSync9(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
@@ -8843,8 +9291,8 @@ async function skillsRoutes(app) {
         return reply.send({ success: true, name, analysis });
       } catch (err) {
         try {
-          if (fs16.existsSync(skillDir)) {
-            fs16.rmSync(skillDir, { recursive: true, force: true });
+          if (fs17.existsSync(skillDir)) {
+            fs17.rmSync(skillDir, { recursive: true, force: true });
           }
           removeFromApprovedList(name);
         } catch {
@@ -8878,15 +9326,23 @@ async function skillsRoutes(app) {
       }
       try {
         const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
-        const binDir = path16.join(agentHome, "bin");
+        const binDir = path17.join(agentHome, "bin");
         const socketGroup = process.env["AGENSHIELD_SOCKET_GROUP"] || "ash_default";
-        const skillDir = path16.join(getSkillsDir(), name);
-        addToApprovedList(name, meta.author);
+        const skillDir = path17.join(getSkillsDir(), name);
+        addToApprovedList(name, meta.author, void 0, meta.slug);
+        const taggedFiles = await Promise.all(files.map(async (f) => {
+          let content = f.content;
+          if (/SKILL\.md$/i.test(f.name)) {
+            content = stripEnvFromSkillMd2(content);
+            content = await injectInstallationTag(content);
+          }
+          return { name: f.name, content, type: f.type };
+        }));
         const brokerAvailable = await isBrokerAvailable();
         if (brokerAvailable) {
           const brokerResult = await installSkillViaBroker(
             name,
-            files.map((f) => ({ name: f.name, content: f.content })),
+            taggedFiles.map((f) => ({ name: f.name, content: f.content })),
             { createWrapper: true, agentHome, socketGroup }
           );
           if (!brokerResult.installed) {
@@ -8898,11 +9354,11 @@ async function skillsRoutes(app) {
             }
           }
         } else {
-          fs16.mkdirSync(skillDir, { recursive: true });
-          for (const file of files) {
-            const filePath = path16.join(skillDir, file.name);
-            fs16.mkdirSync(path16.dirname(filePath), { recursive: true });
-            fs16.writeFileSync(filePath, file.content, "utf-8");
+          fs17.mkdirSync(skillDir, { recursive: true });
+          for (const file of taggedFiles) {
+            const filePath = path17.join(skillDir, file.name);
+            fs17.mkdirSync(path17.dirname(filePath), { recursive: true });
+            fs17.writeFileSync(filePath, file.content, "utf-8");
           }
           try {
             execSync9(`chown -R root:${socketGroup} "${skillDir}"`, { stdio: "pipe" });
@@ -8914,8 +9370,12 @@ async function skillsRoutes(app) {
         addSkillEntry(name);
         addSkillPolicy(name);
         syncOpenClawFromPolicies(loadConfig().policies);
-        const unblockHash = computeSkillHash(path16.join(getSkillsDir(), name));
+        const unblockHash = computeSkillHash(path17.join(getSkillsDir(), name));
         if (unblockHash) updateApprovedHash(name, unblockHash);
+        try {
+          markDownloadedAsInstalled(name);
+        } catch {
+        }
         console.log(`[Skills] Unblocked and installed skill: ${name}`);
         return reply.send({ success: true, message: `Skill "${name}" approved and installed` });
       } catch (err) {
@@ -8945,7 +9405,7 @@ async function skillsRoutes(app) {
       const skillMdFile = files.find((f) => /skill\.md/i.test(f.name));
       if (skillMdFile) {
         try {
-          const parsed = parseSkillMd2(skillMdFile.content);
+          const parsed = parseSkillMd3(skillMdFile.content);
           if (parsed?.metadata) {
             parsedDescription = parsedDescription || parsed.metadata.description;
             parsedVersion = parsedVersion || parsed.metadata.version;
@@ -8974,10 +9434,10 @@ async function skillsRoutes(app) {
 
 // libs/shield-daemon/src/routes/exec.ts
 init_paths();
-import * as fs17 from "node:fs";
-import * as path17 from "node:path";
+import * as fs18 from "node:fs";
+import * as path18 from "node:path";
 function getAllowedCommandsPath2() {
-  return path17.join(getSystemConfigDir(), "allowed-commands.json");
+  return path18.join(getSystemConfigDir(), "allowed-commands.json");
 }
 var BIN_DIRS = [
   "/usr/bin",
@@ -8990,22 +9450,22 @@ var binCache = null;
 var BIN_CACHE_TTL = 6e4;
 var VALID_NAME = /^[a-zA-Z0-9_-]+$/;
 function loadConfig2() {
-  if (!fs17.existsSync(getAllowedCommandsPath2())) {
+  if (!fs18.existsSync(getAllowedCommandsPath2())) {
     return { version: "1.0.0", commands: [] };
   }
   try {
-    const content = fs17.readFileSync(getAllowedCommandsPath2(), "utf-8");
+    const content = fs18.readFileSync(getAllowedCommandsPath2(), "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: "1.0.0", commands: [] };
   }
 }
 function saveConfig2(config) {
-  const dir = path17.dirname(getAllowedCommandsPath2());
-  if (!fs17.existsSync(dir)) {
-    fs17.mkdirSync(dir, { recursive: true });
+  const dir = path18.dirname(getAllowedCommandsPath2());
+  if (!fs18.existsSync(dir)) {
+    fs18.mkdirSync(dir, { recursive: true });
   }
-  fs17.writeFileSync(getAllowedCommandsPath2(), JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs18.writeFileSync(getAllowedCommandsPath2(), JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function scanSystemBins() {
   const pathDirs = (process.env.PATH ?? "").split(":").filter(Boolean);
@@ -9014,13 +9474,13 @@ function scanSystemBins() {
   const results = [];
   for (const dir of allDirs) {
     try {
-      if (!fs17.existsSync(dir)) continue;
-      const entries = fs17.readdirSync(dir);
+      if (!fs18.existsSync(dir)) continue;
+      const entries = fs18.readdirSync(dir);
       for (const entry of entries) {
         if (seen.has(entry)) continue;
-        const fullPath = path17.join(dir, entry);
+        const fullPath = path18.join(dir, entry);
         try {
-          const stat = fs17.statSync(fullPath);
+          const stat = fs18.statSync(fullPath);
           if (stat.isFile() && (stat.mode & 73) !== 0) {
             seen.add(entry);
             results.push({ name: entry, path: fullPath });
@@ -9073,7 +9533,7 @@ async function execRoutes(app) {
       };
     }
     for (const p of paths) {
-      if (!path17.isAbsolute(p)) {
+      if (!path18.isAbsolute(p)) {
         return {
           success: false,
           error: {
@@ -9415,7 +9875,7 @@ async function authRoutes(app) {
 init_vault();
 import { isSecretEnvVar } from "@agenshield/sandbox";
 init_secret_sync();
-import crypto5 from "node:crypto";
+import crypto6 from "node:crypto";
 function maskValue(value) {
   if (value.length <= 4) return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
   return "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022" + value.slice(-4);
@@ -9510,7 +9970,7 @@ async function secretsRoutes(app) {
       const secrets = await vault.get("secrets") ?? [];
       const resolvedScope = scope ?? (policyIds?.length > 0 ? "policed" : "global");
       const newSecret = {
-        id: crypto5.randomUUID(),
+        id: crypto6.randomUUID(),
         name: name.trim(),
         value,
         policyIds: resolvedScope === "standalone" ? [] : policyIds ?? [],
@@ -9569,18 +10029,18 @@ async function secretsRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/fs.ts
-import * as fs18 from "node:fs";
-import * as path18 from "node:path";
+import * as fs19 from "node:fs";
+import * as path19 from "node:path";
 import * as os6 from "node:os";
 var MAX_ENTRIES = 200;
 async function fsRoutes(app) {
   app.get("/fs/browse", async (request2) => {
     const dirPath = request2.query.path || os6.homedir();
     const showHidden = request2.query.showHidden === "true";
-    const resolvedPath = path18.resolve(dirPath);
+    const resolvedPath = path19.resolve(dirPath);
     let dirents;
     try {
-      dirents = fs18.readdirSync(resolvedPath, { withFileTypes: true });
+      dirents = fs19.readdirSync(resolvedPath, { withFileTypes: true });
     } catch {
       return { success: true, data: { entries: [] } };
     }
@@ -9589,7 +10049,7 @@ async function fsRoutes(app) {
       if (!showHidden && dirent.name.startsWith(".")) continue;
       entries.push({
         name: dirent.name,
-        path: path18.join(resolvedPath, dirent.name),
+        path: path19.join(resolvedPath, dirent.name),
         type: dirent.isDirectory() ? "directory" : "file"
       });
       if (entries.length >= MAX_ENTRIES) break;
@@ -9603,8 +10063,8 @@ async function fsRoutes(app) {
 }
 
 // libs/shield-daemon/src/services/activity-log.ts
-import * as fs19 from "node:fs";
-import * as path19 from "node:path";
+import * as fs20 from "node:fs";
+import * as path20 from "node:path";
 init_paths();
 var ACTIVITY_FILE = "activity.jsonl";
 var MAX_SIZE_BYTES = 100 * 1024 * 1024;
@@ -9622,12 +10082,12 @@ var ActivityLog = class {
   writeCount = 0;
   unsubscribe;
   constructor() {
-    this.filePath = path19.join(getConfigDir(), ACTIVITY_FILE);
+    this.filePath = path20.join(getConfigDir(), ACTIVITY_FILE);
   }
   /** Read historical events from the JSONL file, newest first */
   getHistory(limit = 500) {
-    if (!fs19.existsSync(this.filePath)) return [];
-    const content = fs19.readFileSync(this.filePath, "utf-8");
+    if (!fs20.existsSync(this.filePath)) return [];
+    const content = fs20.readFileSync(this.filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const events = [];
     for (const line of lines) {
@@ -9652,7 +10112,7 @@ var ActivityLog = class {
   }
   append(event) {
     const line = JSON.stringify(event) + "\n";
-    fs19.appendFileSync(this.filePath, line, "utf-8");
+    fs20.appendFileSync(this.filePath, line, "utf-8");
     this.writeCount++;
     if (this.writeCount % PRUNE_INTERVAL === 0) {
       this.rotate();
@@ -9660,7 +10120,7 @@ var ActivityLog = class {
   }
   rotate() {
     try {
-      const stat = fs19.statSync(this.filePath);
+      const stat = fs20.statSync(this.filePath);
       if (stat.size > MAX_SIZE_BYTES) {
         this.truncateBySize();
       }
@@ -9670,15 +10130,15 @@ var ActivityLog = class {
   }
   /** Keep newest half of lines when file exceeds size limit */
   truncateBySize() {
-    const content = fs19.readFileSync(this.filePath, "utf-8");
+    const content = fs20.readFileSync(this.filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const keep = lines.slice(Math.floor(lines.length / 2));
-    fs19.writeFileSync(this.filePath, keep.join("\n") + "\n", "utf-8");
+    fs20.writeFileSync(this.filePath, keep.join("\n") + "\n", "utf-8");
   }
   /** Remove entries older than 24 hours */
   pruneOldEntries() {
-    if (!fs19.existsSync(this.filePath)) return;
-    const content = fs19.readFileSync(this.filePath, "utf-8");
+    if (!fs20.existsSync(this.filePath)) return;
+    const content = fs20.readFileSync(this.filePath, "utf-8");
     const lines = content.split("\n").filter(Boolean);
     const cutoff = Date.now() - MAX_AGE_MS;
     const kept = lines.filter((line) => {
@@ -9690,7 +10150,7 @@ var ActivityLog = class {
       }
     });
     if (kept.length < lines.length) {
-      fs19.writeFileSync(this.filePath, kept.join("\n") + "\n", "utf-8");
+      fs20.writeFileSync(this.filePath, kept.join("\n") + "\n", "utf-8");
     }
   }
 };
@@ -9811,7 +10271,7 @@ async function openclawRoutes(app) {
 }
 
 // libs/shield-daemon/src/routes/rpc.ts
-import * as crypto6 from "node:crypto";
+import * as crypto7 from "node:crypto";
 import * as nodefs from "node:fs";
 
 // libs/shield-daemon/src/policy/url-matcher.ts
@@ -9831,11 +10291,11 @@ function normalizeUrlTarget(url) {
   const trimmed = url.trim();
   try {
     const parsed = new URL(trimmed);
-    let path21 = parsed.pathname;
-    if (path21.length > 1) {
-      path21 = path21.replace(/\/+$/, "");
+    let path24 = parsed.pathname;
+    if (path24.length > 1) {
+      path24 = path24.replace(/\/+$/, "");
     }
-    return `${parsed.protocol}//${parsed.host}${path21}${parsed.search}`;
+    return `${parsed.protocol}//${parsed.host}${path24}${parsed.search}`;
   } catch {
     return trimmed.replace(/\/+$/, "");
   }
@@ -9925,7 +10385,7 @@ function checkUrlPolicy(policies, url) {
 // libs/shield-daemon/src/proxy/server.ts
 import * as http from "node:http";
 import * as net from "node:net";
-function createPerRunProxy(urlPolicies, onActivity, logger) {
+function createPerRunProxy(urlPolicies, onActivity, logger, onBlock) {
   const server = http.createServer((req, res) => {
     onActivity();
     const url = req.url;
@@ -9937,6 +10397,7 @@ function createPerRunProxy(urlPolicies, onActivity, logger) {
     const allowed = checkUrlPolicy(urlPolicies, url);
     if (!allowed) {
       logger(`BLOCKED HTTP ${req.method} ${url}`);
+      onBlock?.(req.method || "GET", url, "http");
       res.writeHead(403, { "Content-Type": "text/plain" });
       res.end("Blocked by AgenShield URL policy");
       return;
@@ -9980,6 +10441,7 @@ function createPerRunProxy(urlPolicies, onActivity, logger) {
     const allowed = checkUrlPolicy(urlPolicies, `https://${hostname2}`);
     if (!allowed) {
       logger(`BLOCKED CONNECT ${hostname2}:${port}`);
+      onBlock?.("CONNECT", `${hostname2}:${port}`, "https");
       clientSocket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
       clientSocket.destroy();
       return;
@@ -10042,7 +10504,16 @@ var ProxyPool = class {
     const logger = (msg) => {
       console.log(`[proxy:${execId.slice(0, 8)}] ${msg}`);
     };
-    const server = createPerRunProxy(urlPolicies, onActivity, logger);
+    const onBlock = (method, target, protocol) => {
+      emitInterceptorEvent({
+        type: "denied",
+        operation: "http_request",
+        target: protocol === "https" ? `https://${target}` : target,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        error: `Blocked by URL policy (${method})`
+      });
+    };
+    const server = createPerRunProxy(urlPolicies, onActivity, logger, onBlock);
     const port = await new Promise((resolve3, reject) => {
       server.listen(0, "127.0.0.1", () => {
         const addr = server.address();
@@ -10121,16 +10592,23 @@ function matchCommandPattern(pattern, target) {
   const firstSpace = target.indexOf(" ");
   const cmd = firstSpace >= 0 ? target.slice(0, firstSpace) : target;
   if (cmd.startsWith("/")) {
-    const basename3 = cmd.split("/").pop() || cmd;
-    normalizedTarget = firstSpace >= 0 ? basename3 + target.slice(firstSpace) : basename3;
+    const basename6 = cmd.split("/").pop() || cmd;
+    normalizedTarget = firstSpace >= 0 ? basename6 + target.slice(firstSpace) : basename6;
   }
   if (trimmed.endsWith(":*")) {
-    const prefix = trimmed.slice(0, -2);
+    let prefix = trimmed.slice(0, -2);
+    if (prefix.includes("/")) {
+      prefix = prefix.split("/").pop() || prefix;
+    }
     const lowerTarget = normalizedTarget.toLowerCase();
     const lowerPrefix = prefix.toLowerCase();
     return lowerTarget === lowerPrefix || lowerTarget.startsWith(lowerPrefix + " ");
   }
-  return normalizedTarget.toLowerCase() === trimmed.toLowerCase();
+  let normalizedPattern = trimmed;
+  if (trimmed.includes("/")) {
+    normalizedPattern = trimmed.split("/").pop() || trimmed;
+  }
+  return normalizedTarget.toLowerCase() === normalizedPattern.toLowerCase();
 }
 function operationToTarget(operation) {
   switch (operation) {
@@ -10173,8 +10651,8 @@ function determineNetworkAccess(_config, matchedPolicy, target) {
   if (matchedPolicy?.networkAccess) return matchedPolicy.networkAccess;
   const cleanTarget = target.startsWith("fork:") ? target.slice(5) : target;
   const cmdPart = cleanTarget.split(" ")[0] || "";
-  const basename3 = cmdPart.includes("/") ? cmdPart.split("/").pop() : cmdPart;
-  if (!NETWORK_COMMANDS.has(basename3.toLowerCase())) return "none";
+  const basename6 = cmdPart.includes("/") ? cmdPart.split("/").pop() : cmdPart;
+  if (!NETWORK_COMMANDS.has(basename6.toLowerCase())) return "none";
   return "proxy";
 }
 async function buildSandboxConfig(config, matchedPolicy, _context, target) {
@@ -10223,7 +10701,7 @@ async function buildSandboxConfig(config, matchedPolicy, _context, target) {
     console.log(`[sandbox] direct network access (no proxy)`);
     sandbox.networkAllowed = true;
   } else if (networkMode === "proxy") {
-    const execId = crypto6.randomUUID();
+    const execId = crypto7.randomUUID();
     const commandBasename = extractCommandBasename(target || "");
     const urlPolicies = filterUrlPoliciesForCommand(config.policies || [], commandBasename);
     const pool = getProxyPool();
@@ -10288,7 +10766,11 @@ async function evaluatePolicyCheck(operation, target, context) {
       } else if (targetType === "command") {
         matches = matchCommandPattern(pattern, effectiveTarget);
       } else {
-        const regex = globToRegex(pattern);
+        let fsPattern = pattern;
+        if (targetType === "filesystem" && fsPattern.endsWith("/")) {
+          fsPattern = fsPattern + "**";
+        }
+        const regex = globToRegex(fsPattern);
         matches = regex.test(effectiveTarget);
       }
       console.log("[policy_check]   pattern:", pattern, "-> base:", targetType === "url" ? normalizeUrlBase(pattern) : pattern, "| target:", effectiveTarget, "| matches:", matches);
@@ -10354,12 +10836,29 @@ async function handleHttpRequest(params) {
     body: responseBody
   };
 }
+async function handlePolicyCheck(params) {
+  const operation = String(params["operation"] ?? "");
+  const target = String(params["target"] ?? "");
+  const context = params["context"];
+  const result = await evaluatePolicyCheck(operation, target, context);
+  if (!result.allowed) {
+    if (operation === "exec") {
+      emitExecDenied(target, result.reason || "Denied by policy");
+    } else {
+      emitInterceptorEvent({
+        type: "denied",
+        operation,
+        target,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        policyId: result.policyId,
+        error: result.reason || "Denied by policy"
+      });
+    }
+  }
+  return result;
+}
 var handlers = {
-  policy_check: (params) => evaluatePolicyCheck(
-    String(params["operation"] ?? ""),
-    String(params["target"] ?? ""),
-    params["context"]
-  ),
+  policy_check: (params) => handlePolicyCheck(params),
   events_batch: (params) => handleEventsBatch(params),
   http_request: (params) => handleHttpRequest(params),
   ping: () => ({ status: "ok" })
@@ -10475,22 +10974,22 @@ async function registerRoutes(app) {
 }
 
 // libs/shield-daemon/src/static.ts
-import * as fs20 from "node:fs";
-import * as path20 from "node:path";
+import * as fs21 from "node:fs";
+import * as path21 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path20.dirname(__filename);
+var __dirname = path21.dirname(__filename);
 function getUiAssetsPath() {
-  const pkgRootPath = path20.join(__dirname, "..", "ui-assets");
-  if (fs20.existsSync(pkgRootPath)) {
+  const pkgRootPath = path21.join(__dirname, "..", "ui-assets");
+  if (fs21.existsSync(pkgRootPath)) {
     return pkgRootPath;
   }
-  const bundledPath = path20.join(__dirname, "ui-assets");
-  if (fs20.existsSync(bundledPath)) {
+  const bundledPath = path21.join(__dirname, "ui-assets");
+  if (fs21.existsSync(bundledPath)) {
     return bundledPath;
   }
-  const devPath = path20.join(__dirname, "..", "..", "..", "dist", "apps", "shield-ui");
-  if (fs20.existsSync(devPath)) {
+  const devPath = path21.join(__dirname, "..", "..", "..", "dist", "apps", "shield-ui");
+  if (fs21.existsSync(devPath)) {
     return devPath;
   }
   return null;
@@ -10580,10 +11079,16 @@ async function startServer(config) {
   startSecurityWatcher(1e4);
   const agentHome = process.env["AGENSHIELD_AGENT_HOME"] || "/Users/ash_default_agent";
   const skillsDir2 = `${agentHome}/.openclaw/skills`;
-  if (!fs21.existsSync(skillsDir2)) {
-    fs21.mkdirSync(skillsDir2, { recursive: true, mode: 493 });
+  if (!fs23.existsSync(skillsDir2)) {
+    fs23.mkdirSync(skillsDir2, { recursive: true, mode: 493 });
     console.log(`[Daemon] Created skills directory: ${skillsDir2}`);
   }
+  try {
+    await getInstallationKey();
+    console.log("[Daemon] Installation key ready");
+  } catch (err) {
+    console.warn("[Daemon] Failed to initialize installation key:", err.message);
+  }
   startSkillsWatcher(skillsDir2, {
     onUntrustedDetected: (info) => emitSkillUntrustedDetected(info.name, info.reason),
     onApproved: (name) => emitSkillApproved(name)
@@ -10632,10 +11137,10 @@ async function main() {
   ensureConfigDir();
   const config = loadConfig();
   const pidPath = getPidPath();
-  fs23.writeFileSync(pidPath, process.pid.toString(), "utf-8");
+  fs24.writeFileSync(pidPath, process.pid.toString(), "utf-8");
   const cleanup = () => {
-    if (fs23.existsSync(pidPath)) {
-      fs23.unlinkSync(pidPath);
+    if (fs24.existsSync(pidPath)) {
+      fs24.unlinkSync(pidPath);
     }
     process.exit(0);
   };