velaclaw-dev 0.2.0

package/scripts/shared-skill-combo-test.mjs

@@ -0,0 +1,282 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+import {
+  acceptInvitationByCode,
+  createInvitationForTeam,
+  createTeam,
+  createTeamAssetProposal,
+  getTeamMemberWorkspaceById,
+  getTeamAssetServerManifestBySlug,
+  runMemberRuntimeActionForTeam
+} from "../dist/data.js";
+
+const execFileAsync = promisify(execFile);
+const ROOT = process.env.VELACLAW_ROOT
+  ? path.resolve(process.env.VELACLAW_ROOT)
+  : path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const TMP_ROOT = "/tmp";
+const AWESOME_REPO = "https://github.com/VoltAgent/awesome-openclaw-skills";
+const OFFICIAL_SKILLS_REPO = "https://github.com/openclaw/skills";
+const AWESOME_DIR = path.join(TMP_ROOT, "awesome-openclaw-skills");
+const SKILLS_DIR = path.join(TMP_ROOT, "openclaw-skills");
+
+const SELECTED_SKILLS = [
+  {
+    slug: "second-level-thinking",
+    sourcePath: "skills/0xezreal/second-level-thinking/SKILL.md",
+    sourceUrl: `${OFFICIAL_SKILLS_REPO}/tree/main/skills/0xezreal/second-level-thinking`
+  },
+  {
+    slug: "merge-drafts",
+    sourcePath: "skills/0xcjl/merge-drafts/SKILL.md",
+    sourceUrl: `${OFFICIAL_SKILLS_REPO}/tree/main/skills/0xcjl/merge-drafts`
+  },
+  {
+    slug: "humanizer-cn",
+    sourcePath: "skills/0xcjl/humanizer-cn/SKILL.md",
+    sourceUrl: `${OFFICIAL_SKILLS_REPO}/tree/main/skills/0xcjl/humanizer-cn`
+  }
+];
+
+const COMBO_PROMPT = [
+  "请合并下面两份关于一家电力基础设施公司的投资中文草稿，使用 second-level thinking 质疑市场共识，并对最终中文稿做去除 AI 痕迹的人性化处理。",
+  "",
+  "草稿A：市场普遍认为该公司将直接受益于 AI 数据中心扩张，因此未来三年收入会高速增长，估值仍然合理。",
+  "",
+  "草稿B：这个投资逻辑也许过于线性，因为电力审批、资本开支和供应链可能拖慢兑现速度，但公司仍有区域垄断优势。",
+  "",
+  "输出一版合并后的最终中文稿，不要只列提纲。"
+].join("\n");
+
+async function run(command, args, options = {}) {
+  const result = await execFileAsync(command, args, {
+    cwd: options.cwd || ROOT,
+    maxBuffer: 1024 * 1024 * 16
+  });
+  return {
+    stdout: String(result.stdout || ""),
+    stderr: String(result.stderr || "")
+  };
+}
+
+async function ensureRepo(dirPath, remoteUrl) {
+  try {
+    await fs.access(dirPath);
+  } catch {
+    await run("git", ["clone", "--depth", "1", remoteUrl, dirPath], { cwd: TMP_ROOT });
+    return;
+  }
+
+  await run("git", ["-C", dirPath, "fetch", "--depth", "1", "origin", "main"]);
+  await run("git", ["-C", dirPath, "reset", "--hard", "origin/main"]);
+}
+
+function parseSkillName(content, fallback) {
+  const match = content.match(/^name:\s*(.+)$/m);
+  return match?.[1]?.trim() || fallback;
+}
+
+async function ensureReadTool(configPath) {
+  const raw = JSON.parse(await fs.readFile(configPath, "utf8"));
+  raw.tools ??= {};
+  raw.tools.alsoAllow = Array.from(new Set([...(Array.isArray(raw.tools.alsoAllow) ? raw.tools.alsoAllow : []), "read"]));
+  raw.tools.fs = {
+    ...(typeof raw.tools.fs === "object" && raw.tools.fs ? raw.tools.fs : {}),
+    workspaceOnly: true
+  };
+  await fs.writeFile(configPath, `${JSON.stringify(raw, null, 2)}\n`, "utf8");
+}
+
+function composeProjectNameForMember(teamSlug, memberId) {
+  const base = `member-${teamSlug}-${memberId}`
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  if (base.length <= 48) {
+    return base;
+  }
+  return `${base.slice(0, 39)}-${memberId.slice(-8)}`;
+}
+
+async function waitForRuntimeHealthy(teamSlug, memberId, timeoutMs = 90000) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const raw = await fs.readFile(path.join(ROOT, "state", "team.json"), "utf8").catch(() => null);
+    if (!raw) {
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      continue;
+    }
+    const { stdout } = await run("curl", ["-sS", `http://127.0.0.1:4318/api/teams/${teamSlug}/members/${memberId}/runtime`]);
+    const payload = JSON.parse(stdout);
+    if (payload?.runtime?.container?.health === "healthy") {
+      return payload.runtime;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
+  throw new Error(`runtime did not become healthy for ${memberId}`);
+}
+
+async function findSessionId(sessionsPath, sessionKeySuffix, timeoutMs = 30000) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const raw = JSON.parse(await fs.readFile(sessionsPath, "utf8"));
+    for (const [key, value] of Object.entries(raw)) {
+      if (key.includes(sessionKeySuffix)) {
+        return value.sessionId;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+  throw new Error(`session not found for ${sessionKeySuffix}`);
+}
+
+async function main() {
+  await fs.mkdir(path.join(ROOT, "artifacts"), { recursive: true });
+  await ensureRepo(AWESOME_DIR, AWESOME_REPO);
+  await ensureRepo(SKILLS_DIR, OFFICIAL_SKILLS_REPO);
+
+  const awesomeFiles = await fs.readdir(path.join(AWESOME_DIR, "categories"));
+  const awesomeCorpus = [
+    await fs.readFile(path.join(AWESOME_DIR, "README.md"), "utf8"),
+    ...(await Promise.all(awesomeFiles.map((file) => fs.readFile(path.join(AWESOME_DIR, "categories", file), "utf8"))))
+  ].join("\n");
+  const teamSuffix = Date.now();
+  const team = await createTeam({
+    name: `Skill Combo Test ${teamSuffix}`,
+    slug: `skill-combo-test-${teamSuffix}`,
+    description: "Shared skill combination regression test",
+    managerLabel: "Test Manager"
+  });
+
+  const importedSkills = [];
+  for (const skill of SELECTED_SKILLS) {
+    const content = await fs.readFile(path.join(SKILLS_DIR, skill.sourcePath), "utf8");
+    const title = parseSkillName(content, skill.slug);
+    const result = await createTeamAssetProposal({
+      teamSlug: team.slug,
+      category: "shared-skills",
+      title,
+      content,
+      submittedByLabel: "manager",
+      sourceZone: "collab"
+    });
+    importedSkills.push({
+      slug: skill.slug,
+      title,
+      assetId: result.asset.id,
+      status: result.asset.status,
+      sourceUrl: skill.sourceUrl,
+      listedInAwesome: awesomeCorpus.includes(skill.slug)
+    });
+  }
+
+  const invitation = await createInvitationForTeam(team.slug, {
+    inviteeLabel: "Skill Combo Probe",
+    memberId: "skill-combo-probe@team.local",
+    memberEmail: "skill-combo-probe@team.local",
+    role: "member",
+    createdBy: "shared-skill-combo-test"
+  });
+  const accepted = await acceptInvitationByCode(invitation.code, {
+    identityName: "Skill Combo Probe"
+  });
+
+  const memberId = accepted.policy.memberId;
+  const memberRoot = path.join(ROOT, "members", team.slug, memberId, "runtime");
+  const configPath = path.join(memberRoot, "config", "openclaw.json");
+  await ensureReadTool(configPath);
+  await run("sudo", ["-n", "docker", "compose", "-p", composeProjectNameForMember(team.slug, memberId), "-f", path.join(memberRoot, "docker-compose.yml"), "up", "-d"], {
+    cwd: memberRoot
+  });
+
+  const runtime = await waitForRuntimeHealthy(team.slug, memberId);
+  const workspace = await getTeamMemberWorkspaceById(team.slug, memberId);
+  const manifest = await getTeamAssetServerManifestBySlug(team.slug);
+  const workspaceSkillFiles = (await fs.readdir(path.join(memberRoot, "workspace", "skills"))).sort();
+
+  const containerName = runtime.containerName;
+  const sessionKeySuffix = "combo-skill-run";
+  const { stdout: agentOutput } = await run(
+    "sudo",
+    [
+      "-n",
+      "docker",
+      "exec",
+      containerName,
+      "sh",
+      "-lc",
+      `cd /app && openclaw agent --session-id ${sessionKeySuffix} --message ${JSON.stringify(COMBO_PROMPT)} --json`
+    ]
+  );
+  const agentResult = JSON.parse(agentOutput);
+
+  const sessionsPath = path.join(memberRoot, "config", "agents", "main", "sessions", "sessions.json");
+  const sessionId = await findSessionId(sessionsPath, sessionKeySuffix);
+  const sessions = JSON.parse(await fs.readFile(sessionsPath, "utf8"));
+  const sessionEntry = sessions[`agent:main:explicit:${sessionKeySuffix}`];
+  const jsonlPath = path.join(memberRoot, "config", "agents", "main", "sessions", `${sessionId}.jsonl`);
+  const jsonlLines = (await fs.readFile(jsonlPath, "utf8"))
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+
+  const assistantToolCalls = jsonlLines
+    .filter((entry) => entry.type === "message" && entry.message?.role === "assistant")
+    .flatMap((entry) => entry.message.content || [])
+    .filter((content) => content.type === "toolCall")
+    .map((content) => ({
+      name: content.name,
+      arguments: content.arguments
+    }));
+
+  const finalAssistantText = agentResult?.result?.payloads?.map((entry) => entry.text).filter(Boolean).join("\n\n") || "";
+  const skillsSnapshot = sessionEntry?.skillsSnapshot || {};
+  const loadedSkills = (skillsSnapshot.skills || []).map((entry) => entry.name);
+  const loadedSharedSkills = loadedSkills.filter((name) =>
+    ["humanizer-cn", "merge-drafts", "second-level-thinking"].includes(name)
+  );
+
+  const report = {
+    createdAt: new Date().toISOString(),
+    sourceRepos: {
+      awesome: AWESOME_REPO,
+      officialSkills: OFFICIAL_SKILLS_REPO
+    },
+    team: team,
+    member: {
+      memberId,
+      runtime
+    },
+    importedSkills,
+    workspaceSkillFiles,
+    manifestItems: manifest.items.map((item) => ({ title: item.title, kind: item.kind })),
+    session: {
+      sessionId,
+      sessionKey: `agent:main:explicit:${sessionKeySuffix}`,
+      loadedSkills,
+      loadedSharedSkills,
+      assistantToolCalls,
+      finalAssistantText
+    },
+    checks: {
+      importedSkillsPublished: importedSkills.every((skill) => skill.status === "published"),
+      workspaceHasThreeSharedSkills: workspaceSkillFiles.filter((name) => name.startsWith("team-shared-")).length >= 3,
+      skillsSnapshotIncludesSharedSkills: loadedSharedSkills.length === 3,
+      usesReadToolForSharedSkills: assistantToolCalls.some((call) => call.name === "read"),
+      finalAssistantTextPresent: Boolean(finalAssistantText.trim())
+    }
+  };
+
+  const artifactPath = path.join(ROOT, "artifacts", `shared-skill-combo-test-${teamSuffix}.json`);
+  await fs.writeFile(artifactPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+  console.log(JSON.stringify({ artifactPath, report }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack || error.message : String(error));
+  process.exitCode = 1;
+});

package/scripts/team-load-test.mjs

@@ -0,0 +1,358 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import { promisify } from "node:util";
+import { fileURLToPath } from "node:url";
+
+const execFileAsync = promisify(execFile);
+
+const ROOT = process.env.VELACLAW_ROOT
+  ? path.resolve(process.env.VELACLAW_ROOT)
+  : path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const BASE_URL = process.env.VELACLAW_BASE_URL || "http://127.0.0.1:4318";
+const TEAM_SIZE = Number(process.env.TEAM_SIZE || "100");
+const CONCURRENCY = Number(process.env.CONCURRENCY || "10");
+const RUN_STAMP = new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+const TEAM_SLUG = process.env.TEAM_SLUG || `loadtest-${TEAM_SIZE}-${RUN_STAMP}`;
+const TEAM_NAME = process.env.TEAM_NAME || `Load Test ${RUN_STAMP}`;
+const REPORT_PATH = path.join(ROOT, "artifacts", `${TEAM_SLUG}.json`);
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+function memberId(index) {
+  return `lt-${String(index).padStart(3, "0")}`;
+}
+
+function fakeUserId(index) {
+  return `9${String(500000000 + index).padStart(9, "0")}`;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+async function parseBody(response) {
+  const text = await response.text();
+  const type = response.headers.get("content-type") || "";
+  if (type.includes("application/json")) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return text;
+}
+
+async function request(pathname, { method = "GET", headers = {}, body } = {}) {
+  const response = await fetch(`${BASE_URL}${pathname}`, {
+    method,
+    headers,
+    body
+  });
+  const parsed = await parseBody(response);
+  if (!response.ok) {
+    throw new Error(`${method} ${pathname} failed: ${response.status} ${typeof parsed === "string" ? parsed : JSON.stringify(parsed)}`);
+  }
+  return parsed;
+}
+
+async function postJson(pathname, payload) {
+  return request(pathname, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+}
+
+async function postForm(pathname, payload) {
+  return request(pathname, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(payload).toString()
+  });
+}
+
+async function mapLimit(items, limit, worker) {
+  const results = new Array(items.length);
+  let cursor = 0;
+
+  async function run() {
+    while (true) {
+      const index = cursor;
+      cursor += 1;
+      if (index >= items.length) return;
+      try {
+        results[index] = await worker(items[index], index);
+      } catch (error) {
+        results[index] = {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => run()));
+  return results;
+}
+
+async function writeReport(report) {
+  await fs.mkdir(path.dirname(REPORT_PATH), { recursive: true });
+  await fs.writeFile(REPORT_PATH, `${JSON.stringify(report, null, 2)}\n`);
+}
+
+async function runDockerReadChecks(teamSlug) {
+  const teamCurrent = path.join(ROOT, "teams", teamSlug, "assets", "current");
+  const member1PrivateSkills = path.join(ROOT, "members", teamSlug, "lt-001", "private-skills");
+  const member2PrivateSkills = path.join(ROOT, "members", teamSlug, "lt-002", "private-skills");
+
+  const readSharedAndWritePrivate = await execFileAsync(
+    "sudo",
+    [
+      "-n",
+      "docker",
+      "run",
+      "--rm",
+      "-v",
+      `${teamCurrent}:/mnt/team-shared:ro`,
+      "-v",
+      `${member1PrivateSkills}:/mnt/private-skills:rw`,
+      "postgres:16-alpine",
+      "sh",
+      "-lc",
+      [
+        "set -eu",
+        "ls -1 /mnt/team-shared/shared-skills",
+        "grep -q 'Shared Skill Alpha' /mnt/team-shared/shared-skills/shared-skill-alpha.md",
+        "if touch /mnt/team-shared/shared-skills/should-not-write 2>/dev/null; then echo shared_write=unexpected; exit 21; else echo shared_write=blocked; fi",
+        "printf 'runtime-private-check\\n' > /mnt/private-skills/runtime-private-check.txt",
+        "test -f /mnt/private-skills/runtime-private-check.txt",
+        "echo private_write=ok"
+      ].join("; ")
+    ],
+    { maxBuffer: 1024 * 1024 * 4 }
+  );
+
+  const isolatePrivate = await execFileAsync(
+    "sudo",
+    [
+      "-n",
+      "docker",
+      "run",
+      "--rm",
+      "-v",
+      `${member2PrivateSkills}:/mnt/private-skills:rw`,
+      "postgres:16-alpine",
+      "sh",
+      "-lc",
+      [
+        "set -eu",
+        "test -f /mnt/private-skills/lt-002-private-skill.md",
+        "if test -f /mnt/private-skills/lt-001-private-skill.md; then echo leak; exit 22; else echo isolated=ok; fi"
+      ].join("; ")
+    ],
+    { maxBuffer: 1024 * 1024 * 4 }
+  );
+
+  return {
+    sharedReadPrivateWrite: readSharedAndWritePrivate.stdout.trim(),
+    privateIsolation: isolatePrivate.stdout.trim()
+  };
+}
+
+async function main() {
+  const report = {
+    startedAt: nowIso(),
+    baseUrl: BASE_URL,
+    team: {
+      slug: TEAM_SLUG,
+      name: TEAM_NAME,
+      size: TEAM_SIZE
+    },
+    timingsMs: {},
+    inviteStats: {},
+    acceptStats: {},
+    assetChecks: {},
+    runtimeChecks: {},
+    notes: []
+  };
+
+  const createTeamStarted = performance.now();
+  const createdTeam = await postJson("/api/teams", {
+    name: TEAM_NAME,
+    slug: TEAM_SLUG,
+    description: `Automated ${TEAM_SIZE}-member load test`,
+    managerLabel: "Load Test Manager"
+  });
+  report.timingsMs.createTeam = Math.round(performance.now() - createTeamStarted);
+  report.team.profile = createdTeam.profile;
+
+  const inviteInputs = Array.from({ length: TEAM_SIZE }, (_, offset) => {
+    const index = offset + 1;
+    return {
+      memberId: memberId(index),
+      inviteeLabel: `Load Test Member ${index}`,
+      role: index === 1 ? "publisher" : index === 2 ? "member" : "member",
+      note: "automated-load-test",
+      dailyMessages: 80 + index,
+      monthlyMessages: 2000 + index,
+      maxSubagents: index === 1 ? 2 : 1,
+      maxThinking: index === 1 ? "medium" : "low"
+    };
+  });
+
+  const inviteStarted = performance.now();
+  const invitationResults = await mapLimit(inviteInputs, CONCURRENCY, async (payload) => {
+    const result = await postJson(`/api/teams/${TEAM_SLUG}/invitations`, payload);
+    return {
+      ok: true,
+      memberId: payload.memberId,
+      role: payload.role,
+      code: result.invitation.code
+    };
+  });
+  report.timingsMs.createInvitations = Math.round(performance.now() - inviteStarted);
+  report.inviteStats = {
+    total: invitationResults.length,
+    ok: invitationResults.filter((entry) => entry?.ok).length,
+    failed: invitationResults.filter((entry) => !entry?.ok).slice(0, 5)
+  };
+  assert(report.inviteStats.ok === TEAM_SIZE, `expected ${TEAM_SIZE} invitations, got ${report.inviteStats.ok}`);
+
+  const acceptStarted = performance.now();
+  const acceptResults = await mapLimit(invitationResults, CONCURRENCY, async (entry, index) => {
+    const payload = {
+      telegramUserId: fakeUserId(index + 1),
+      identityName: `LoadTest-${entry.memberId}`
+    };
+    const html = await postForm(`/invite/${entry.code}/accept`, payload);
+    return {
+      ok: typeof html === "string" && html.includes("is now staged"),
+      memberId: entry.memberId
+    };
+  });
+  report.timingsMs.acceptInvitations = Math.round(performance.now() - acceptStarted);
+  report.acceptStats = {
+    total: acceptResults.length,
+    ok: acceptResults.filter((entry) => entry?.ok).length,
+    failed: acceptResults.filter((entry) => !entry?.ok).slice(0, 5)
+  };
+  assert(report.acceptStats.ok === TEAM_SIZE, `expected ${TEAM_SIZE} accepted members, got ${report.acceptStats.ok}`);
+
+  const overviewStarted = performance.now();
+  const overview = await request(`/api/teams/${TEAM_SLUG}`);
+  report.timingsMs.fetchOverview = Math.round(performance.now() - overviewStarted);
+  report.overviewSummary = overview.summary;
+  assert(overview.summary.memberCount === TEAM_SIZE, `team overview memberCount=${overview.summary.memberCount}`);
+
+  const publishedPortSet = new Set(
+    overview.members
+      .map((member) => member.runtime?.publishedPort)
+      .filter((value) => Number.isInteger(value))
+  );
+  report.runtimeChecks.portUniqueness = {
+    expected: TEAM_SIZE,
+    actualUnique: publishedPortSet.size
+  };
+  assert(publishedPortSet.size === TEAM_SIZE, `expected ${TEAM_SIZE} unique ports, got ${publishedPortSet.size}`);
+
+  const managerAsset = await postJson(`/api/teams/${TEAM_SLUG}/assets/proposals`, {
+    category: "shared-skills",
+    title: "Shared Skill Alpha",
+    content: "# Shared Skill Alpha\n\nUse this shared skill for load test verification.\n",
+    submittedByLabel: "manager",
+    note: "manager direct publish"
+  });
+  const publisherAsset = await postJson(`/api/teams/${TEAM_SLUG}/assets/proposals`, {
+    category: "shared-skills",
+    title: "Shared Skill Beta",
+    content: "# Shared Skill Beta\n\nPublished by a trusted publisher member.\n",
+    submittedByMemberId: "lt-001",
+    note: "publisher direct publish"
+  });
+  const memberAsset = await postJson(`/api/teams/${TEAM_SLUG}/assets/proposals`, {
+    category: "shared-skills",
+    title: "Shared Skill Gamma",
+    content: "# Shared Skill Gamma\n\nSubmitted by a normal member and should require approval.\n",
+    submittedByMemberId: "lt-002",
+    note: "member requires approval"
+  });
+  assert(memberAsset.asset.status === "pending_approval", `expected pending approval asset, got ${memberAsset.asset.status}`);
+  const approvedMemberAsset = await postJson(`/api/teams/${TEAM_SLUG}/assets/${memberAsset.asset.id}/approve`, {
+    approvedByMemberId: "manager"
+  });
+
+  const sharedSkillDir = path.join(ROOT, "teams", TEAM_SLUG, "assets", "current", "shared-skills");
+  const sharedSkillFiles = (await fs.readdir(sharedSkillDir)).sort();
+  report.assetChecks = {
+    managerAssetStatus: managerAsset.asset.status,
+    publisherAssetStatus: publisherAsset.asset.status,
+    memberAssetInitialStatus: memberAsset.asset.status,
+    memberAssetAfterApprove: approvedMemberAsset.asset.status,
+    sharedSkillFiles
+  };
+
+  await fs.writeFile(
+    path.join(ROOT, "members", TEAM_SLUG, "lt-001", "private-skills", "lt-001-private-skill.md"),
+    "# LT-001 Private Skill\n\nOnly member lt-001 should see this file.\n"
+  );
+  await fs.writeFile(
+    path.join(ROOT, "members", TEAM_SLUG, "lt-002", "private-skills", "lt-002-private-skill.md"),
+    "# LT-002 Private Skill\n\nOnly member lt-002 should see this file.\n"
+  );
+
+  const memberOneAssets = await request(`/api/teams/${TEAM_SLUG}/members/lt-001/assets`);
+  const memberTwoAssets = await request(`/api/teams/${TEAM_SLUG}/members/lt-002/assets`);
+  const memberOnePrivateSkills = memberOneAssets.buckets.find((bucket) => bucket.key === "private-skills");
+  const memberTwoPrivateSkills = memberTwoAssets.buckets.find((bucket) => bucket.key === "private-skills");
+
+  report.assetChecks.memberOnePrivateSkillFiles = memberOnePrivateSkills?.files.map((file) => file.name) ?? [];
+  report.assetChecks.memberTwoPrivateSkillFiles = memberTwoPrivateSkills?.files.map((file) => file.name) ?? [];
+
+  const sampleComposePath = path.join(ROOT, "members", TEAM_SLUG, "lt-001", "runtime", "docker-compose.yml");
+  const sampleCompose = await fs.readFile(sampleComposePath, "utf8");
+  report.runtimeChecks.composeHasPrivateMounts = [
+    "../../private-memory:/home/node/.openclaw/workspace/private-memory:rw",
+    "../../private-skills:/home/node/.openclaw/workspace/private-skills:rw",
+    "../../private-tools:/home/node/.openclaw/workspace/private-tools:rw",
+    "../../private-docs:/home/node/.openclaw/workspace/private-docs:rw",
+    `/home/node/.openclaw/workspace/team-shared:ro`
+  ].every((segment) => sampleCompose.includes(segment));
+  assert(report.runtimeChecks.composeHasPrivateMounts, "sample compose file is missing expected shared/private mounts");
+
+  report.runtimeChecks.dockerMountProbe = await runDockerReadChecks(TEAM_SLUG);
+
+  const finalOverview = await request(`/api/teams/${TEAM_SLUG}`);
+  report.finalOverviewSummary = finalOverview.summary;
+  report.finishedAt = nowIso();
+
+  await writeReport(report);
+  console.log(JSON.stringify(report, null, 2));
+}
+
+main().catch(async (error) => {
+  const failureReport = {
+    startedAt: nowIso(),
+    baseUrl: BASE_URL,
+    team: {
+      slug: TEAM_SLUG,
+      name: TEAM_NAME,
+      size: TEAM_SIZE
+    },
+    failedAt: nowIso(),
+    error: error instanceof Error ? error.message : String(error)
+  };
+  try {
+    await writeReport(failureReport);
+  } catch {
+    // ignore secondary failure while reporting
+  }
+  console.error(JSON.stringify(failureReport, null, 2));
+  process.exitCode = 1;
+});

package/scripts/verify-install.mjs

@@ -0,0 +1,44 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = process.env.VELACLAW_ROOT
+  ? path.resolve(process.env.VELACLAW_ROOT)
+  : path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const BASE_URL = process.env.VELACLAW_BASE_URL || "http://127.0.0.1:4318";
+
+async function fetchJson(pathname) {
+  const response = await fetch(`${BASE_URL}${pathname}`);
+  const text = await response.text();
+  let payload;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = text;
+  }
+  if (!response.ok) {
+    throw new Error(`${pathname} -> ${response.status} ${typeof payload === "string" ? payload : JSON.stringify(payload)}`);
+  }
+  return payload;
+}
+
+async function main() {
+  const health = await fetchJson("/health");
+  const teams = await fetchJson("/api/teams");
+  console.log(
+    JSON.stringify(
+      {
+        root: ROOT,
+        baseUrl: BASE_URL,
+        health,
+        teamCount: Array.isArray(teams?.teams) ? teams.teams.length : 0
+      },
+      null,
+      2
+    )
+  );
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});