@silicaclaw/cli 2026.3.19-1 → 2026.3.19-2

package/openclaw-skills/silicaclaw-broadcast/scripts/owner-forwarder-demo.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+
+const API_BASE = String(process.env.SILICACLAW_API_BASE || "http://localhost:4310").replace(/\/+$/, "");
+const POLL_INTERVAL_MS = Math.max(1000, Number(process.env.OPENCLAW_FORWARDER_INTERVAL_MS || 5000) || 5000);
+const LIMIT = Math.max(1, Number(process.env.OPENCLAW_FORWARDER_LIMIT || 20) || 20);
+const OWNER_FORWARD_CMD = String(process.env.OPENCLAW_OWNER_FORWARD_CMD || "").trim();
+
+function scoreMessage(message) {
+  const text = String(message?.body || "").toLowerCase();
+  if (!text) return "learn_only";
+  if (
+    text.includes("error") ||
+    text.includes("failed") ||
+    text.includes("failure") ||
+    text.includes("blocked") ||
+    text.includes("approval") ||
+    text.includes("security") ||
+    text.includes("credential") ||
+    text.includes("payment") ||
+    text.includes("fund") ||
+    text.includes("deploy") ||
+    text.includes("completed")
+  ) {
+    return "forward_summary";
+  }
+  return "learn_only";
+}
+
+function summarizeForOwner(message) {
+  const source = `${message.display_name || "Unknown"} (${message.topic || "global"})`;
+  const body = String(message.body || "").trim();
+  return [
+    `Source: ${source}`,
+    "Why it matters: a SilicaClaw public broadcast matched the OpenClaw owner-forwarding policy.",
+    `What happened: ${body.slice(0, 220)}${body.length > 220 ? "..." : ""}`,
+    `Action: Review if owner follow-up is needed.`,
+  ].join("\n");
+}
+
+async function dispatchToOwner(route, summary, message) {
+  if (!OWNER_FORWARD_CMD) {
+    console.log("");
+    console.log(`[${route}]`);
+    console.log(summary);
+    return;
+  }
+
+  await new Promise((resolve, reject) => {
+    const child = spawn(OWNER_FORWARD_CMD, {
+      shell: true,
+      stdio: ["pipe", "inherit", "inherit"],
+      env: process.env,
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`owner dispatch failed (exit=${code ?? "unknown"})`));
+    });
+    child.stdin.write(JSON.stringify({
+      route,
+      summary,
+      message: {
+        message_id: message.message_id || "",
+        display_name: message.display_name || "",
+        topic: message.topic || "global",
+        body: message.body || "",
+      },
+    }, null, 2));
+    child.stdin.end();
+  });
+}
+
+async function request(path, options = {}) {
+  const res = await fetch(`${API_BASE}${path}`, {
+    headers: { "Content-Type": "application/json" },
+    ...options,
+  });
+  const json = await res.json().catch(() => null);
+  if (!res.ok || !json?.ok) {
+    throw new Error(json?.error?.message || `Request failed (${res.status})`);
+  }
+  return json.data;
+}
+
+async function main() {
+  const seen = new Set();
+  console.log(`OpenClaw owner forwarder demo watching ${API_BASE}`);
+  while (true) {
+    const payload = await request(`/api/openclaw/bridge/messages?limit=${LIMIT}`);
+    const items = Array.isArray(payload?.items) ? payload.items.slice().reverse() : [];
+    for (const item of items) {
+      if (!item?.message_id || seen.has(item.message_id)) continue;
+      seen.add(item.message_id);
+      const route = scoreMessage(item);
+      if (route === "learn_only") continue;
+      const summary = summarizeForOwner(item);
+      await dispatchToOwner(route, summary, item);
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/openclaw-skills/silicaclaw-broadcast/scripts/send-to-owner-via-openclaw.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { resolve } from "node:path";
+
+function requiredEnv(name) {
+  const value = String(process.env[name] || "").trim();
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+}
+
+function resolveOpenClawCommand() {
+  const explicitBin = String(process.env.OPENCLAW_BIN || "").trim();
+  if (explicitBin) {
+    return { cmd: explicitBin, args: [] };
+  }
+
+  const sourceDir = String(process.env.OPENCLAW_SOURCE_DIR || "").trim();
+  if (sourceDir) {
+    return {
+      cmd: "node",
+      args: [resolve(sourceDir, "openclaw.mjs")],
+    };
+  }
+
+  return { cmd: "openclaw", args: [] };
+}
+
+function main() {
+  const payload = JSON.parse(readFileSync(0, "utf8"));
+  const channel = requiredEnv("OPENCLAW_OWNER_CHANNEL");
+  const target = requiredEnv("OPENCLAW_OWNER_TARGET");
+  const account = String(process.env.OPENCLAW_OWNER_ACCOUNT || "").trim();
+  const message = String(payload?.summary || "").trim();
+  if (!message) {
+    throw new Error("Missing summary in stdin payload");
+  }
+
+  const command = resolveOpenClawCommand();
+  const args = [
+    ...command.args,
+    "message",
+    "send",
+    "--channel",
+    channel,
+    "--target",
+    target,
+    "--message",
+    message,
+  ];
+  if (account) {
+    args.push("--account", account);
+  }
+
+  const result = spawnSync(command.cmd, args, {
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+  process.exit(result.status ?? 1);
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silicaclaw/cli",
-  "version": "2026.3.19-1",
+  "version": "2026.3.19-2",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -27,6 +27,7 @@
     "packages/storage/src/**",
     "packages/storage/tsconfig.json",
     "scripts/",
+    "openclaw-skills/",
     "docs/",
     "social.md.example",
     "openclaw.social.md.example",

package/packages/core/dist/socialConfig.js

@@ -263,7 +263,7 @@ function generateDefaultSocialMdTemplate(options = {}) {
     const displayName = options.display_name?.trim() || "My OpenClaw Agent";
     const bio = options.bio?.trim() || "Local AI agent running on this machine";
     const tags = Array.isArray(options.tags) && options.tags.length > 0 ? options.tags : ["openclaw", "local-first"];
-    const mode = options.mode ?? "lan";
+    const mode = options.mode ?? "global-preview";
     const publicEnabled = typeof options.public_enabled === "boolean" ? options.public_enabled : false;
     return `---
 enabled: true

package/packages/core/dist/socialTemplate.js

@@ -34,7 +34,7 @@ function generateSocialMdTemplate(runtimeConfig) {
     const tags = asStringArray(profile?.tags, ["openclaw", "local-first"]);
     const mode = network?.mode === "local" || network?.mode === "lan" || network?.mode === "global-preview"
         ? network.mode
-        : "lan";
+        : "global-preview";
     const discoverable = asBool(discovery?.discoverable, true);
     const allowProfileBroadcast = asBool(discovery?.allow_profile_broadcast, true);
     const allowPresenceBroadcast = asBool(discovery?.allow_presence_broadcast, true);

package/packages/core/src/socialConfig.ts

@@ -420,7 +420,7 @@ export function generateDefaultSocialMdTemplate(options: DefaultSocialTemplateOp
   const displayName = options.display_name?.trim() || "My OpenClaw Agent";
   const bio = options.bio?.trim() || "Local AI agent running on this machine";
   const tags = Array.isArray(options.tags) && options.tags.length > 0 ? options.tags : ["openclaw", "local-first"];
-  const mode = options.mode ?? "lan";
+  const mode = options.mode ?? "global-preview";
   const publicEnabled = typeof options.public_enabled === "boolean" ? options.public_enabled : false;
   return `---
 enabled: true

package/packages/core/src/socialTemplate.ts

@@ -39,7 +39,7 @@ export function generateSocialMdTemplate(runtimeConfig: SocialRuntimeConfig | nu
   const mode =
     network?.mode === "local" || network?.mode === "lan" || network?.mode === "global-preview"
       ? network.mode
-      : "lan";
+      : "global-preview";
 
   const discoverable = asBool(discovery?.discoverable, true);
   const allowProfileBroadcast = asBool(discovery?.allow_profile_broadcast, true);

package/packages/network/dist/relayPreview.js

@@ -357,18 +357,20 @@ class RelayPreviewAdapter {
             const endpoint = this.signalingEndpoints[index]?.replace(/\/+$/, "");
             if (!endpoint)
                 continue;
+            let timeout = null;
             try {
                 const controller = new AbortController();
-                const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+                timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
                 const response = await fetch(`${endpoint}${path}`, {
                     method,
                     headers: method === "POST" ? { "content-type": "application/json" } : undefined,
                     body: method === "POST" ? JSON.stringify(body) : undefined,
                     signal: controller.signal,
                 });
-                clearTimeout(timeout);
                 if (!response.ok) {
-                    throw new Error(`${method} ${path} failed (${response.status})`);
+                    const responseText = (await response.text().catch(() => "")).trim();
+                    const detail = responseText ? `: ${responseText.slice(0, 200)}` : "";
+                    throw new Error(`${method} ${path} failed (${response.status})${detail}`);
                 }
                 this.activeEndpointIndex = index;
                 this.activeEndpoint = endpoint;
@@ -376,7 +378,12 @@ class RelayPreviewAdapter {
                 return response.json();
             }
             catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
+                const isAbort = error instanceof Error && (error.name === "AbortError" || error.message === "This operation was aborted");
+                const message = isAbort
+                    ? `${method} ${path} timed out after ${this.requestTimeoutMs}ms`
+                    : error instanceof Error
+                        ? error.message
+                        : String(error);
                 errors.push(`${endpoint}: ${message}`);
                 this.stats.signaling_errors += 1;
                 this.lastError = message;
@@ -384,6 +391,11 @@ class RelayPreviewAdapter {
                 this.reconnectAttemptsTotal += 1;
                 this.recordDiscovery("signaling_error", { endpoint, detail: message });
             }
+            finally {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+            }
         }
         throw new Error(errors.join(" | "));
     }

package/packages/network/src/relayPreview.ts

@@ -480,31 +480,44 @@ export class RelayPreviewAdapter implements NetworkAdapter {
       const index = (this.activeEndpointIndex + offset) % this.signalingEndpoints.length;
       const endpoint = this.signalingEndpoints[index]?.replace(/\/+$/, "");
       if (!endpoint) continue;
+      let timeout: NodeJS.Timeout | null = null;
       try {
         const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+        timeout = setTimeout(() => controller.abort(), this.requestTimeoutMs);
         const response = await fetch(`${endpoint}${path}`, {
           method,
           headers: method === "POST" ? { "content-type": "application/json" } : undefined,
           body: method === "POST" ? JSON.stringify(body) : undefined,
           signal: controller.signal,
         });
-        clearTimeout(timeout);
         if (!response.ok) {
-          throw new Error(`${method} ${path} failed (${response.status})`);
+          const responseText = (await response.text().catch(() => "")).trim();
+          const detail = responseText ? `: ${responseText.slice(0, 200)}` : "";
+          throw new Error(`${method} ${path} failed (${response.status})${detail}`);
         }
         this.activeEndpointIndex = index;
         this.activeEndpoint = endpoint;
         this.lastError = null;
         return response.json();
       } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
+        const isAbort = error instanceof Error && (
+          error.name === "AbortError" || error.message === "This operation was aborted"
+        );
+        const message = isAbort
+          ? `${method} ${path} timed out after ${this.requestTimeoutMs}ms`
+          : error instanceof Error
+            ? error.message
+            : String(error);
         errors.push(`${endpoint}: ${message}`);
         this.stats.signaling_errors += 1;
         this.lastError = message;
         this.lastErrorAt = Date.now();
         this.reconnectAttemptsTotal += 1;
         this.recordDiscovery("signaling_error", { endpoint, detail: message });
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
       }
     }
     throw new Error(errors.join(" | "));

package/scripts/functional-check.mjs

@@ -55,6 +55,17 @@ async function main() {
     'ROADMAP.md',
     'CHANGELOG.md',
     'VERSION',
+    'openclaw-owner-forward.env.example',
+    'openclaw-skills/silicaclaw-broadcast/SKILL.md',
+    'openclaw-skills/silicaclaw-broadcast/VERSION',
+    'openclaw-skills/silicaclaw-broadcast/manifest.json',
+    'openclaw-skills/silicaclaw-broadcast/agents/openai.yaml',
+    'openclaw-skills/silicaclaw-broadcast/references/owner-forwarding-policy.md',
+    'openclaw-skills/silicaclaw-broadcast/references/owner-dispatch-adapter.md',
+    'openclaw-skills/silicaclaw-broadcast/references/computer-control-via-openclaw.md',
+    'openclaw-skills/silicaclaw-broadcast/scripts/owner-dispatch-adapter-demo.mjs',
+    'openclaw-skills/silicaclaw-broadcast/scripts/send-to-owner-via-openclaw.mjs',
+    'openclaw-skills/silicaclaw-broadcast/scripts/owner-forwarder-demo.mjs',
     'apps/local-console/public/index.html',
     'apps/public-explorer/public/index.html',
     'data/cache.json',
@@ -78,6 +89,19 @@ async function main() {
   checkInlineScriptSyntax(path.resolve(root, 'apps/local-console/public/index.html'));
   checkInlineScriptSyntax(path.resolve(root, 'apps/public-explorer/public/index.html'));
 
+  const skillBody = readFileSync(path.resolve(root, 'openclaw-skills/silicaclaw-broadcast/SKILL.md'), 'utf8');
+  assert(skillBody.includes('name: silicaclaw-broadcast'), 'OpenClaw skill metadata missing');
+  const skillManifest = JSON.parse(readFileSync(path.resolve(root, 'openclaw-skills/silicaclaw-broadcast/manifest.json'), 'utf8'));
+  assert(skillManifest.name === 'silicaclaw-broadcast', 'OpenClaw skill manifest missing name');
+  assert(skillManifest.references?.owner_forwarding_policy === 'references/owner-forwarding-policy.md', 'OpenClaw skill manifest missing owner forwarding reference');
+  assert(skillManifest.references?.owner_dispatch_adapter === 'references/owner-dispatch-adapter.md', 'OpenClaw skill manifest missing owner dispatch adapter reference');
+  assert(skillManifest.references?.computer_control_via_openclaw === 'references/computer-control-via-openclaw.md', 'OpenClaw skill manifest missing computer control reference');
+  assert(skillManifest.entrypoints?.owner_forwarder_demo === 'scripts/owner-forwarder-demo.mjs', 'OpenClaw skill manifest missing owner forwarder demo entrypoint');
+  assert(skillManifest.entrypoints?.owner_dispatch_adapter_demo === 'scripts/owner-dispatch-adapter-demo.mjs', 'OpenClaw skill manifest missing owner dispatch adapter demo entrypoint');
+  assert(skillManifest.entrypoints?.owner_send_via_openclaw === 'scripts/send-to-owner-via-openclaw.mjs', 'OpenClaw skill manifest missing owner send via openclaw entrypoint');
+  const skillUi = readFileSync(path.resolve(root, 'openclaw-skills/silicaclaw-broadcast/agents/openai.yaml'), 'utf8');
+  assert(skillUi.includes('display_name: "SilicaClaw Broadcast"'), 'OpenClaw skill UI metadata missing');
+
   // Import built modules (requires npm run build)
   const core = await import(pathToFileURL(path.resolve(root, 'packages/core/dist/index.js')).href);
   const network = await import(pathToFileURL(path.resolve(root, 'packages/network/dist/index.js')).href);
@@ -185,6 +209,11 @@ async function main() {
   try {
     const bridgeStatus = service.getOpenClawBridgeStatus();
     assert(typeof bridgeStatus.agent_id === 'string', 'Bridge status missing agent_id');
+    assert(typeof bridgeStatus.openclaw_installation?.detected === 'boolean', 'Bridge status missing OpenClaw installation detection');
+    assert(Array.isArray(bridgeStatus.skill_learning?.skills), 'Bridge status missing skill learning list');
+    assert(bridgeStatus.owner_delivery?.mode === 'public-broadcast-via-openclaw', 'Bridge status missing owner delivery mode');
+    assert(typeof bridgeStatus.owner_delivery?.bridge_messages_readable === 'boolean', 'Bridge status missing owner delivery readability state');
+    assert(typeof bridgeStatus.owner_delivery?.forward_command_configured === 'boolean', 'Bridge status missing owner forward command state');
 
     const bridgeProfile = service.getOpenClawBridgeProfile();
     assert(bridgeProfile?.profile, 'Bridge profile payload missing profile');

package/scripts/install-openclaw-skill.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT_DIR = resolve(__dirname, "..");
+
+function listSkillDirs(root) {
+  if (!existsSync(root)) return [];
+  return readdirSync(root)
+    .map((name) => ({ name, path: resolve(root, name) }))
+    .filter((entry) => {
+      try {
+        return statSync(entry.path).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+}
+
+function main() {
+  const sourceRoot = resolve(ROOT_DIR, "openclaw-skills");
+  const targetRoot = resolve(homedir(), ".openclaw", "workspace", "skills");
+  const legacyTargetRoot = resolve(homedir(), ".openclaw", "skills");
+  const skills = listSkillDirs(sourceRoot);
+
+  if (!skills.length) {
+    throw new Error("No bundled OpenClaw skills found.");
+  }
+
+  mkdirSync(targetRoot, { recursive: true });
+  mkdirSync(legacyTargetRoot, { recursive: true });
+
+  for (const skill of skills) {
+    cpSync(skill.path, resolve(targetRoot, skill.name), { recursive: true, force: true });
+    cpSync(skill.path, resolve(legacyTargetRoot, skill.name), { recursive: true, force: true });
+  }
+
+  console.log(JSON.stringify({
+    installed: skills.map((skill) => ({
+      name: skill.name,
+      target_path: resolve(targetRoot, skill.name),
+      legacy_target_path: resolve(legacyTargetRoot, skill.name),
+    })),
+    target_root: targetRoot,
+    legacy_target_root: legacyTargetRoot,
+  }, null, 2));
+}
+
+main();

package/scripts/openclaw-bridge-adapter.mjs

@@ -26,6 +26,9 @@ export function createOpenClawBridgeClient(options = {}) {
     async getStatus() {
       return bridgeRequest(apiBase, "/api/openclaw/bridge");
     },
+    async getConfig() {
+      return bridgeRequest(apiBase, "/api/openclaw/bridge/config");
+    },
     async getProfile() {
       return bridgeRequest(apiBase, "/api/openclaw/bridge/profile");
     },
@@ -73,6 +76,10 @@ export async function getOpenClawBridgeProfile(options = {}) {
   return createOpenClawBridgeClient(options).getProfile();
 }
 
+export async function getOpenClawBridgeConfig(options = {}) {
+  return createOpenClawBridgeClient(options).getConfig();
+}
+
 export async function listOpenClawBridgeMessages(options = {}) {
   return createOpenClawBridgeClient(options).listMessages(options);
 }

package/scripts/openclaw-bridge-client.mjs

@@ -57,6 +57,7 @@ function printHelp() {
   section("Commands");
   kv("help", "Show this help");
   kv("status", "Show bridge status");
+  kv("config", "Show suggested OpenClaw config");
   kv("profile", "Show resolved identity/profile payload");
   kv("messages", "List recent public messages");
   kv("send --body=...", "Publish a signed public message");
@@ -102,6 +103,38 @@ async function showStatus() {
   kv("identity_source", status.identity_source || "-");
   kv("social_source", status.social_source_path || "-");
   console.log("");
+  section("OpenClaw");
+  kv("installed", String(Boolean(status.openclaw_installation?.detected)));
+  kv("detect_mode", status.openclaw_installation?.detection_mode || "-");
+  kv("command_path", status.openclaw_installation?.command_path || "-");
+  kv("workspace_dir", status.openclaw_installation?.workspace_dir || "-");
+  kv("home_dir", status.openclaw_installation?.home_dir || "-");
+  kv("identity_path", status.openclaw_identity_source_path || "-");
+  kv("skills_path", status.openclaw_installation?.home_skills_path || status.openclaw_installation?.workspace_skills_path || "-");
+  console.log("");
+  section("Skill Learning");
+  kv("available", String(Boolean(status.skill_learning?.available)));
+  const skills = Array.isArray(status.skill_learning?.skills) ? status.skill_learning.skills : [];
+  if (!skills.length) {
+    kv("skills", "-");
+  } else {
+    for (const skill of skills) {
+      kv(skill.key, `${skill.endpoint} (${skill.summary})`);
+    }
+  }
+  console.log("");
+  section("Owner Delivery");
+  kv("supported", String(Boolean(status.owner_delivery?.supported)));
+  kv("mode", status.owner_delivery?.mode || "-");
+  kv("bridge_readable", String(Boolean(status.owner_delivery?.bridge_messages_readable)));
+  kv("forward_cmd", String(Boolean(status.owner_delivery?.forward_command_configured)));
+  kv("cmd_resolvable", String(Boolean(status.owner_delivery?.openclaw_command_resolvable)));
+  kv("ready", String(Boolean(status.owner_delivery?.ready)));
+  kv("send_to_owner", String(Boolean(status.owner_delivery?.send_to_owner_via_openclaw)));
+  kv("owner_channel", status.owner_delivery?.owner_channel || "-");
+  kv("owner_target", status.owner_delivery?.owner_target || "-");
+  kv("reason", status.owner_delivery?.reason || "-");
+  console.log("");
   section("Endpoints");
   for (const [key, value] of Object.entries(status.endpoints || {})) {
     kv(key, `${API_BASE}${value}`);
@@ -113,6 +146,11 @@ async function showProfile() {
   console.log(toPrettyJson(profile));
 }
 
+async function showConfig() {
+  const config = await client.getConfig();
+  console.log(toPrettyJson(config));
+}
+
 async function listMessages() {
   const limit = Number(parseFlag("limit", "24")) || 24;
   const agentId = parseFlag("agent-id", "");
@@ -154,6 +192,10 @@ async function main() {
     await showProfile();
     return;
   }
+  if (cmd === "config") {
+    await showConfig();
+    return;
+  }
   if (cmd === "messages") {
     await listMessages();
     return;

package/scripts/pack-openclaw-skill.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const ROOT_DIR = resolve(__dirname, "..");
+
+function parseFlag(name, fallback = "") {
+  const prefix = `--${name}=`;
+  for (const item of process.argv.slice(2)) {
+    if (item.startsWith(prefix)) return item.slice(prefix.length);
+  }
+  return fallback;
+}
+
+function main() {
+  const skillName = parseFlag("skill", "silicaclaw-broadcast");
+  const skillsRoot = resolve(ROOT_DIR, "openclaw-skills");
+  const skillDir = resolve(skillsRoot, skillName);
+  if (!existsSync(skillDir)) {
+    throw new Error(`Skill not found: ${skillName}`);
+  }
+
+  const outDir = resolve(ROOT_DIR, "dist", "openclaw-skills");
+  mkdirSync(outDir, { recursive: true });
+  const archivePath = resolve(outDir, `${skillName}.tgz`);
+
+  const result = spawnSync("tar", ["-czf", archivePath, "-C", skillsRoot, skillName], {
+    cwd: ROOT_DIR,
+    stdio: "pipe",
+    encoding: "utf8",
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if ((result.status ?? 1) !== 0) {
+    throw new Error(String(result.stderr || result.stdout || "tar failed").trim());
+  }
+
+  const digest = createHash("sha256").update(readFileSync(archivePath)).digest("hex");
+  const checksumPath = `${archivePath}.sha256`;
+  writeFileSync(checksumPath, `${digest}  ${resolve(outDir, `${skillName}.tgz`).split("/").pop()}\n`, "utf8");
+
+  console.log(JSON.stringify({
+    skill: skillName,
+    source_dir: skillDir,
+    archive_path: archivePath,
+    sha256: digest,
+    checksum_path: checksumPath,
+  }, null, 2));
+}
+
+main();

package/scripts/silicaclaw-cli.mjs

@@ -486,6 +486,9 @@ function help() {
   kv("Connect", "silicaclaw connect");
   kv("OpenClaw Demo", "silicaclaw openclaw-demo");
   kv("OpenClaw Bridge", "silicaclaw openclaw-bridge status");
+  kv("OpenClaw Skill", "silicaclaw openclaw-skill-install");
+  kv("Pack Skill", "silicaclaw openclaw-skill-pack");
+  kv("Check Skill", "silicaclaw openclaw-skill-validate");
   kv("Logs", "silicaclaw logs local-console");
   kv("Doctor", "silicaclaw doctor");
   kv("Help", "silicaclaw help");
@@ -527,6 +530,21 @@ switch (cmd) {
       cwd: process.cwd(),
     });
     break;
+  case "openclaw-skill-install":
+    run("node", [resolve(ROOT_DIR, "scripts", "install-openclaw-skill.mjs"), ...process.argv.slice(3)], {
+      cwd: process.cwd(),
+    });
+    break;
+  case "openclaw-skill-pack":
+    run("node", [resolve(ROOT_DIR, "scripts", "pack-openclaw-skill.mjs"), ...process.argv.slice(3)], {
+      cwd: process.cwd(),
+    });
+    break;
+  case "openclaw-skill-validate":
+    run("node", [resolve(ROOT_DIR, "scripts", "validate-openclaw-skill.mjs"), ...process.argv.slice(3)], {
+      cwd: process.cwd(),
+    });
+    break;
   case "start":
   case "stop":
   case "restart":