@jstn-sdk/ma 0.1.13 → 0.14.1

package/scripts/install.sh

@@ -1,8 +1,20 @@
 #!/usr/bin/env sh
 set -eu
 
-MA_PACKAGE="${MA_PACKAGE:-@jstn-sdk/ma@latest}"
+MA_PACKAGE="${MA_PACKAGE:-@jstn-sdk/ma@0.14.1}"
 CODEX_PACKAGE="${CODEX_PACKAGE:-@openai/codex@latest}"
+NO_SETUP=0
+NO_SKILLS=0
+DRY_RUN=0
+
+for arg in "$@"; do
+  case "$arg" in
+    --no-setup) NO_SETUP=1 ;;
+    --no-skills) NO_SKILLS=1 ;;
+    --dry-run) DRY_RUN=1 ;;
+    *) echo "meta-architect install: unknown option: $arg" >&2; exit 2 ;;
+  esac
+done
 
 need_cmd() {
   command -v "$1" >/dev/null 2>&1 || {
@@ -14,14 +26,31 @@ need_cmd() {
 need_cmd npm
 need_cmd node
 
-echo "meta-architect install: installing Codex + Meta-Architect"
+echo "meta-architect install: plan"
+echo "  install: $CODEX_PACKAGE $MA_PACKAGE"
+echo "  setup: $([ "$NO_SETUP" -eq 1 ] && echo disabled || echo enabled)"
+echo "  skills: $([ "$NO_SKILLS" -eq 1 ] && echo disabled || echo enabled)"
+echo "  undo: npm uninstall -g $MA_PACKAGE $CODEX_PACKAGE"
+
+if [ "$DRY_RUN" -eq 1 ]; then
+  echo "meta-architect install: dry-run complete"
+  exit 0
+fi
+
+if [ "$NO_SKILLS" -eq 1 ]; then export MA_SKIP_SKILLS=1; fi
 npm i -g "$CODEX_PACKAGE" "$MA_PACKAGE"
+echo "meta-architect install: versions"
+node --version
+npm --version
+command -v codex >/dev/null 2>&1 && codex --version || echo "codex: unavailable"
 
-if command -v ma >/dev/null 2>&1; then
+if command -v ma >/dev/null 2>&1 && [ "$NO_SETUP" -eq 0 ]; then
   echo "meta-architect install: seeding local MA runtime"
-  ma setup >/dev/null
+  ma setup
   echo "meta-architect install: ready"
   echo "start: ma --madmax --high"
+elif [ "$NO_SETUP" -eq 1 ]; then
+  echo "meta-architect install: setup disabled by --no-setup"
 else
   echo "meta-architect install: ma command not found after npm install" >&2
   exit 1

package/scripts/install.sh.sha256

@@ -0,0 +1 @@
+3ffac1b709bceb6343181fef3402fa3bed6a9d9067299a2938489a4d3458ad41  scripts/install.sh

package/scripts/linux-package-smoke.mjs

@@ -3,9 +3,9 @@
 import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import process from "node:process";
+import { createTestNamespace } from "../src/test-fixtures.js";
 import {
   getDebArtifactPath,
   getPacmanArtifactPath,
@@ -61,7 +61,7 @@ async function main() {
     throw new Error("Native Linux package smoke validation is supported only on Linux hosts");
   }
 
-  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "meta-architect-linux-smoke-"));
+  const tempRoot = createTestNamespace("meta-architect-linux-smoke");
   const debExtractRoot = path.join(tempRoot, "deb");
   const pacmanExtractRoot = path.join(tempRoot, "pacman");
   const rpmExtractRoot = path.join(tempRoot, "rpm");

package/scripts/package-size-check.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+
+const budget = Number(process.env.MA_PACKAGE_SIZE_BUDGET ?? 5 * 1024 * 1024);
+const result = spawnSync("npm", ["pack", "--dry-run", "--json", "--ignore-scripts"], {
+  encoding: "utf8",
+});
+if (result.status !== 0) throw new Error(result.stderr || "npm pack inspection failed");
+const pack = JSON.parse(result.stdout)[0];
+const excludedMedia = pack.files.filter((file) => /docs\/assets\//.test(file.path));
+if (excludedMedia.length > 0)
+  throw new Error(
+    `Heavy demo media included: ${excludedMedia.map((file) => file.path).join(", ")}`,
+  );
+const unexpectedExecutables = pack.files.filter(
+  (file) =>
+    file.mode === 493 && !file.path.startsWith("bin/") && !/^scripts\/[^/]+\.sh$/.test(file.path),
+);
+if (unexpectedExecutables.length > 0) {
+  throw new Error(
+    `Unexpected executable package files: ${unexpectedExecutables.map((file) => file.path).join(", ")}`,
+  );
+}
+console.log(`package size: ${pack.size} bytes (budget ${budget})`);
+if (pack.size > budget) throw new Error(`Package exceeds ${budget} byte budget`);

package/scripts/plugin-build.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const skillsRoot = path.join(repoRoot, "skills");
+const sourcePluginRoot = path.join(repoRoot, "plugins", "meta-architect");
+const packageJson = JSON.parse(await fs.readFile(path.join(repoRoot, "package.json"), "utf8"));
+
+const TARGETS = {
+  codex: {
+    support: "native",
+    description: "Codex plugin bundle with native skills, app metadata, and MCP metadata.",
+    install:
+      "Copy this directory to a Codex plugin location or load it with the host plugin loader.",
+    publish: "Publish the generated directory through the Codex plugin distribution flow.",
+  },
+  "claude-code": {
+    support: "native",
+    description: "Claude Code marketplace repository containing a native plugin source.",
+    install:
+      "/plugin marketplace add <owner>/<marketplace-repository> then /plugin install meta-architect@<marketplace>",
+    publish: "Commit this directory to a Git repository, then add it as a Claude Code marketplace.",
+  },
+  cursor: {
+    support: "native",
+    description: "Cursor marketplace repository containing native skills and rules.",
+    install: "Install the generated marketplace repository through Cursor's plugin flow.",
+    publish:
+      "Commit this directory to a Git repository and submit or distribute it as a Cursor marketplace.",
+  },
+  antigravity: {
+    support: "native",
+    description: "Antigravity plugin directory with native rules and skills.",
+    install:
+      "Copy this directory into .agents/plugins/ in the workspace or the host plugin directory.",
+    publish: "Distribute the generated plugin directory through the Antigravity plugin flow.",
+  },
+  "gemini-cli": {
+    support: "native",
+    description: "Gemini CLI extension with a context file and Agent Skills.",
+    install: "gemini extensions install <github-url-or-local-path>",
+    publish: "Push this directory to GitHub, then install it with gemini extensions install.",
+  },
+  opencode: {
+    support: "native",
+    description: "OpenCode project package using its native .opencode/skills surface.",
+    install: "Copy .opencode/skills into the OpenCode project.",
+    publish: "Distribute this directory through Git or the OpenCode package mechanism.",
+  },
+  pi: {
+    support: "native",
+    description: "Pi package surface distributed by the @jstn-sdk/ma package.",
+    install:
+      "pi install npm:@jstn-sdk/ma@<version> or pi install git:github.com/JustineDevs/meta-architect@v<version>",
+    publish: "Publish @jstn-sdk/ma once; no separate Pi package is created.",
+  },
+  openclaw: {
+    support: "portable",
+    description:
+      "OpenClaw-compatible skills bundle. No runtime plugin is invented for a skills-only source.",
+    install: "Copy skills/ into the OpenClaw workspace and load the generated AGENTS.md context.",
+    publish:
+      "Publish the bundle through the OpenClaw skills or ClawHub flow after adding a real runtime entrypoint.",
+  },
+  cline: {
+    support: "native",
+    description: "Cline project rules and native skills bundle.",
+    install: "Copy .clinerules and .cline/skills into the Cline project.",
+    publish: "Distribute the generated project bundle through Git or the Cline host flow.",
+  },
+  continue: {
+    support: "portable",
+    description: "Continue-compatible rules bundle with the portable Agent Skills baseline.",
+    install: "Copy .continue/rules and skills into the Continue project.",
+    publish: "Distribute the generated bundle through Git or the Continue configuration flow.",
+  },
+  goose: {
+    support: "portable",
+    description: "Goose-compatible portable context and skills bundle.",
+    install: "Copy AGENTS.md and skills/ into the Goose workspace.",
+    publish: "Distribute the generated bundle through Git or the Goose extension flow.",
+  },
+};
+
+export const supportedPluginTargets = Object.freeze(Object.keys(TARGETS));
+
+function parseArgs(argv) {
+  const targets = [];
+  let output = path.join(repoRoot, "dist", "vendor-plugins");
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--target" || arg === "--targets") {
+      targets.push(...(argv[index + 1] ?? "").split(",").filter(Boolean));
+      index += 1;
+    } else if (arg === "--output") {
+      output = path.resolve(argv[index + 1] ?? output);
+      index += 1;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log("Usage: npm run plugin:build -- --targets all [--output DIR]");
+      process.exit(0);
+    }
+  }
+  const selected = targets.length === 0 || targets.includes("all") ? Object.keys(TARGETS) : targets;
+  for (const target of selected) {
+    if (!Object.hasOwn(TARGETS, target)) throw new Error(`Unknown plugin target: ${target}`);
+  }
+  return { output, targets: [...new Set(selected)] };
+}
+
+async function copyTree(source, destination) {
+  const stat = await fs.lstat(source);
+  if (stat.isSymbolicLink()) return copyTree(await fs.realpath(source), destination);
+  if (stat.isDirectory()) {
+    await fs.mkdir(destination, { recursive: true });
+    for (const entry of await fs.readdir(source)) {
+      await copyTree(path.join(source, entry), path.join(destination, entry));
+    }
+    return;
+  }
+  await fs.mkdir(path.dirname(destination), { recursive: true });
+  await fs.copyFile(source, destination);
+  await fs.chmod(destination, stat.mode & 0o777);
+}
+
+async function writeJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+async function writeText(filePath, content) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content.endsWith("\n") ? content : `${content}\n`, "utf8");
+}
+
+async function copySkills(destination) {
+  await copyTree(skillsRoot, destination);
+}
+
+function baselineInstructions(target) {
+  return `# Meta-Architect (${target})\n\nUse the bundled Meta-Architect lanes as the canonical workflow contract:\n\n\`$arch\` -> \`$sage\` -> \`$flow\` -> \`$vet\` -> \`$vibe\` -> \`$build\`\n\nRun each lane through this host's native skill or rule loader. Do not claim a gate passed without fresh evidence.\n`;
+}
+
+function cursorRule() {
+  return `---\ndescription: Meta-Architect gated workflow\nglobs:\n  - "**/*"\nalwaysApply: false\n---\n\nUse the Meta-Architect skills in this plugin in order: $arch, $sage, $flow, $vet, $vibe, then $build. Keep build and release work blocked until the earlier lanes have fresh evidence.\n`;
+}
+
+async function buildCodex(output) {
+  await copyTree(path.join(sourcePluginRoot, ".codex-plugin"), path.join(output, ".codex-plugin"));
+  await copySkills(path.join(output, "skills"));
+  for (const file of [".app.json", ".mcp.json", "README.md"]) {
+    await copyTree(path.join(sourcePluginRoot, file), path.join(output, file));
+  }
+}
+
+async function buildClaude(output) {
+  const plugin = path.join(output, "plugins", "meta-architect");
+  await writeJson(path.join(output, ".claude-plugin", "marketplace.json"), {
+    name: "meta-architect",
+    owner: { name: "JustineDevs", url: "https://github.com/JustineDevs" },
+    metadata: { description: "Meta-Architect gated workflow plugin", version: packageJson.version },
+    plugins: [
+      {
+        name: "meta-architect",
+        source: "./plugins/meta-architect",
+        description: TARGETS["claude-code"].description,
+      },
+    ],
+  });
+  await writeJson(path.join(plugin, ".claude-plugin", "plugin.json"), {
+    name: "meta-architect",
+    description: "Meta-Architect gated workflow skills for Claude Code.",
+    version: packageJson.version,
+    author: { name: "JustineDevs", url: "https://github.com/JustineDevs" },
+    license: "MIT",
+  });
+  await copySkills(path.join(plugin, "skills"));
+  await writeText(path.join(plugin, "AGENTS.md"), baselineInstructions("Claude Code"));
+}
+
+async function buildCursor(output) {
+  const plugin = path.join(output, "plugins", "meta-architect");
+  await writeJson(path.join(output, ".cursor-plugin", "marketplace.json"), {
+    name: "meta-architect",
+    owner: { name: "JustineDevs", email: "justinedevs@jstn.site" },
+    metadata: { description: "Meta-Architect gated workflow plugin", version: packageJson.version },
+    plugins: [
+      {
+        name: "meta-architect",
+        source: "./plugins/meta-architect",
+        description: TARGETS.cursor.description,
+      },
+    ],
+  });
+  await writeJson(path.join(plugin, ".cursor-plugin", "plugin.json"), {
+    name: "meta-architect",
+    displayName: "Meta-Architect",
+    version: packageJson.version,
+    description: "Gated workflow skills for Cursor.",
+    author: { name: "JustineDevs", email: "justinedevs@jstn.site" },
+    license: "MIT",
+    keywords: ["cursor", "plugin", "skills", "workflow"],
+  });
+  await copySkills(path.join(plugin, "skills"));
+  await writeText(path.join(plugin, "rules", "meta-architect.mdc"), cursorRule());
+}
+
+async function buildAntigravity(output) {
+  await writeJson(path.join(output, "plugin.json"), {
+    name: "meta-architect",
+    version: packageJson.version,
+  });
+  await copySkills(path.join(output, "skills"));
+  await writeText(
+    path.join(output, "rules", "meta-architect.md"),
+    baselineInstructions("Antigravity"),
+  );
+}
+
+async function buildGemini(output) {
+  await writeJson(path.join(output, "gemini-extension.json"), {
+    name: "meta-architect",
+    version: packageJson.version,
+    description: "Meta-Architect gated workflow skills for Gemini CLI.",
+    contextFileName: "GEMINI.md",
+  });
+  await writeText(path.join(output, "GEMINI.md"), baselineInstructions("Gemini CLI"));
+  await copySkills(path.join(output, "skills"));
+}
+
+async function buildOpenCode(output) {
+  await copySkills(path.join(output, ".opencode", "skills"));
+  await writeText(path.join(output, "AGENTS.md"), baselineInstructions("OpenCode"));
+}
+
+async function buildPi(output) {
+  await copySkills(path.join(output, "skills"));
+}
+
+async function buildOpenClaw(output) {
+  await copySkills(path.join(output, "skills"));
+  await writeText(path.join(output, "AGENTS.md"), baselineInstructions("OpenClaw"));
+}
+
+async function buildCline(output) {
+  await writeText(path.join(output, ".clinerules"), baselineInstructions("Cline"));
+  await copySkills(path.join(output, ".cline", "skills"));
+}
+
+async function buildContinue(output) {
+  await copySkills(path.join(output, "skills"));
+  await writeText(
+    path.join(output, ".continue", "rules", "meta-architect.md"),
+    baselineInstructions("Continue"),
+  );
+}
+
+async function buildGoose(output) {
+  await copySkills(path.join(output, "skills"));
+  await writeText(path.join(output, "AGENTS.md"), baselineInstructions("Goose"));
+}
+
+const builders = {
+  codex: buildCodex,
+  "claude-code": buildClaude,
+  cursor: buildCursor,
+  antigravity: buildAntigravity,
+  "gemini-cli": buildGemini,
+  opencode: buildOpenCode,
+  pi: buildPi,
+  openclaw: buildOpenClaw,
+  cline: buildCline,
+  continue: buildContinue,
+  goose: buildGoose,
+};
+
+async function buildTarget(target, root) {
+  const output = path.join(root, target);
+  await fs.rm(output, { recursive: true, force: true });
+  await builders[target](output);
+  await writeJson(path.join(output, "BUILD-MANIFEST.json"), {
+    schemaVersion: "1.0",
+    name: "meta-architect",
+    version: packageJson.version,
+    target,
+    support: TARGETS[target].support,
+    source: "skills/",
+    description: TARGETS[target].description,
+    install: TARGETS[target].install,
+    publish: TARGETS[target].publish,
+  });
+  return output;
+}
+
+export async function buildPlugins({ output, targets }) {
+  await fs.mkdir(output, { recursive: true });
+  return Promise.all(targets.map((target) => buildTarget(target, output)));
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const outputs = await buildPlugins(args);
+  console.log(outputs.join("\n"));
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exitCode = 1;
+  });
+}

package/scripts/plugin-publish.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import process from "node:process";
+import { buildPlugins, supportedPluginTargets } from "./plugin-build.js";
+
+const repoRoot = process.cwd();
+const output = path.join(repoRoot, "dist", "vendor-plugins");
+const publishers = {};
+
+function parseArgs(argv) {
+  const targets = [];
+  let execute = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--target" || arg === "--targets") {
+      targets.push(...(argv[index + 1] ?? "").split(",").filter(Boolean));
+      index += 1;
+    } else if (arg === "--execute") {
+      execute = true;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log("Usage: npm run plugin:publish -- --target pi [--execute]");
+      process.exit(0);
+    }
+  }
+  if (targets.length !== 1) throw new Error("plugin:publish requires exactly one --target");
+  if (targets[0] === "all")
+    throw new Error("Publishing all hosts at once is unsafe; publish one target at a time");
+  if (!supportedPluginTargets.includes(targets[0]))
+    throw new Error(`Unknown plugin target: ${targets[0]}`);
+  return { target: targets[0], execute };
+}
+
+async function main() {
+  const { target, execute } = parseArgs(process.argv.slice(2));
+  const [targetRoot] = await buildPlugins({ output, targets: [target] });
+  const publisher = publishers[target];
+  if (!publisher) {
+    console.log(
+      JSON.stringify(
+        {
+          target,
+          status: "prepared",
+          path: targetRoot,
+          next: "Commit the generated directory to the host marketplace or repository required by this host.",
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  if (!execute) {
+    console.log(
+      JSON.stringify(
+        {
+          target,
+          status: "dry-run",
+          path: targetRoot,
+          command: [publisher.command, ...publisher.args].join(" "),
+        },
+        null,
+        2,
+      ),
+    );
+    return;
+  }
+
+  execFileSync(publisher.command, publisher.args, { cwd: targetRoot, stdio: "inherit" });
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exitCode = 1;
+});

package/scripts/plugin-sync.js

@@ -3,6 +3,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
+import { fileURLToPath } from "node:url";
 
 const repoRoot = process.cwd();
 const skillsRoot = path.join(repoRoot, "skills");
@@ -30,10 +31,23 @@ async function copyDir(src, dest) {
   }
 }
 
+async function linkOrCopyDir(src, dest) {
+  if (process.env.MA_PLUGIN_SYNC_MODE !== "copy") {
+    try {
+      await fs.symlink(path.relative(path.dirname(dest), src), dest, "dir");
+      return "symlink";
+    } catch {
+      // Restricted worktrees and Windows may reject directory links.
+    }
+  }
+  await copyDir(src, dest);
+  return "copy";
+}
+
 async function listSkillDirs(root) {
-  const entries = await fs.readdir(root, { withFileTypes: true }).catch(() => []);
+  const entries = await fs.readdir(root, { withFileTypes: true });
   return entries
-    .filter((entry) => entry.isDirectory())
+    .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
     .map((entry) => entry.name)
     .sort();
 }
@@ -53,24 +67,74 @@ async function syncPluginSkills() {
     const src = path.join(skillsRoot, name);
     const dest = path.join(pluginSkillsRoot, name);
     await fs.rm(dest, { recursive: true, force: true });
-    await copyDir(src, dest);
+    await linkOrCopyDir(src, dest);
   }
 
   return skillDirs;
 }
 
-async function verifyPluginSkills() {
-  const skillDirs = await listSkillDirs(skillsRoot);
-  const pluginDirs = await listSkillDirs(pluginSkillsRoot);
-  if (skillDirs.length !== pluginDirs.length) {
-    throw new Error("Plugin skill mirror drift: directory count mismatch");
+async function listFiles(root, current = root, files = []) {
+  const entries = await fs.readdir(current, { withFileTypes: true });
+  for (const entry of entries) {
+    const absolutePath = path.join(current, entry.name);
+    if (entry.isDirectory() || entry.isSymbolicLink()) {
+      await listFiles(root, absolutePath, files);
+    } else if (entry.isFile()) {
+      files.push(path.relative(root, absolutePath));
+    }
+  }
+  return files.sort();
+}
+
+export async function verifyPluginSkills(sourceRoot = skillsRoot, mirrorRoot = pluginSkillsRoot) {
+  await fs.access(sourceRoot);
+  await fs.access(mirrorRoot);
+  const sourceSkillDirs = await listSkillDirs(sourceRoot);
+  const mirrorSkillDirs = await listSkillDirs(mirrorRoot);
+  const filesForSkillDirs = async (root, skillDirs) => {
+    const files = [];
+    for (const skillDir of skillDirs) {
+      for (const relativePath of await listFiles(path.join(root, skillDir))) {
+        files.push(path.join(skillDir, relativePath));
+      }
+    }
+    return files.sort();
+  };
+  const sourceFiles = await filesForSkillDirs(sourceRoot, sourceSkillDirs);
+  const mirrorFiles = await filesForSkillDirs(mirrorRoot, mirrorSkillDirs);
+  if (JSON.stringify(sourceFiles) !== JSON.stringify(mirrorFiles)) {
+    throw new Error("Plugin skill mirror drift: file set mismatch");
   }
 
-  for (let index = 0; index < skillDirs.length; index += 1) {
-    if (skillDirs[index] !== pluginDirs[index]) {
-      throw new Error(
-        `Plugin skill mirror drift: expected ${skillDirs[index]}, found ${pluginDirs[index]}`,
-      );
+  for (const relativePath of sourceFiles) {
+    const sourcePath = path.join(sourceRoot, relativePath);
+    const mirrorPath = path.join(mirrorRoot, relativePath);
+    const [source, mirror, sourceStat, mirrorStat] = await Promise.all([
+      fs.readFile(sourcePath),
+      fs.readFile(mirrorPath),
+      fs.stat(sourcePath),
+      fs.stat(mirrorPath),
+    ]);
+    if (!source.equals(mirror)) {
+      throw new Error(`Plugin skill mirror drift: content mismatch at ${relativePath}`);
+    }
+    if ((sourceStat.mode & 0o777) !== (mirrorStat.mode & 0o777)) {
+      throw new Error(`Plugin skill mirror drift: mode mismatch at ${relativePath}`);
+    }
+  }
+  for (const skillDir of sourceSkillDirs) {
+    const mirrorPath = path.join(mirrorRoot, skillDir);
+    const mirrorStat = await fs.lstat(mirrorPath);
+    if (mirrorStat.isSymbolicLink()) {
+      const [sourceRealPath, mirrorRealPath] = await Promise.all([
+        fs.realpath(path.join(sourceRoot, skillDir)),
+        fs.realpath(mirrorPath),
+      ]);
+      if (sourceRealPath !== mirrorRealPath) {
+        throw new Error(`Plugin skill mirror drift: invalid symlink target at ${skillDir}`);
+      }
+    } else if (!mirrorStat.isDirectory()) {
+      throw new Error(`Plugin skill mirror drift: invalid mirror entry at ${skillDir}`);
     }
   }
 }
@@ -87,7 +151,9 @@ async function main() {
   console.log(pluginSkillsRoot);
 }
 
-main().catch((error) => {
-  console.error(error.message);
-  process.exitCode = 1;
-});
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((error) => {
+    console.error(error.message);
+    process.exitCode = 1;
+  });
+}

package/scripts/prepack.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import process from "node:process";
+
+execFileSync(process.execPath, ["./scripts/plugin-sync.js"], {
+  stdio: "inherit",
+  env: { ...process.env, MA_PLUGIN_SYNC_MODE: "copy" },
+});