@drunkcoding/agents-and-skills 0.0.31 → 0.0.33

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "name": "tech-graph",
       "source": "./plugins/tech-graph",
       "description": "6-step wizard for technical diagrams (SVG/PNG) via fireworks-tech-graph",
-      "version": "0.0.31",
+      "version": "0.0.33",
       "category": "diagram",
       "keywords": [
         "diagram",
@@ -26,7 +26,7 @@
       "name": "html-effectiveness",
       "source": "./plugins/html-effectiveness",
       "description": "Generate self-contained interactive HTML reports from 20 upstream templates via a conversational agent.",
-      "version": "0.0.31",
+      "version": "0.0.33",
       "category": "reports",
       "keywords": [
         "html",
@@ -41,7 +41,7 @@
       "name": "plugin-validator",
       "source": "./plugins/plugin-validator",
       "description": "Orchestrated validator for Claude Code plugins — validates skills, agents, commands, and hooks across every plugin under plugins/**.",
-      "version": "0.0.31",
+      "version": "0.0.33",
       "category": "tooling",
       "keywords": [
         "validation",
@@ -57,7 +57,7 @@
       "name": "team-share",
       "source": "./plugins/team-share",
       "description": "Onboard your team with an interactive setup menu: install CodeGraph, build the Understand-Anything knowledge graph, and share Claude Code settings — run any combination, all idempotent.",
-      "version": "0.0.31",
+      "version": "0.0.33",
       "category": "tooling",
       "keywords": [
         "onboarding",
@@ -68,6 +68,23 @@
         "understand-anything",
         "git-lfs"
       ]
+    },
+    {
+      "name": "multica-tool",
+      "source": "./plugins/multica-tool",
+      "description": "Export, import, and sync Multica skills, agents, and squads between workspaces.",
+      "version": "0.0.33",
+      "category": "workflow",
+      "keywords": [
+        "multica",
+        "migration",
+        "export",
+        "import",
+        "sync",
+        "skills",
+        "agents",
+        "squads"
+      ]
     }
   ]
 }

package/README.md

@@ -14,6 +14,7 @@ Published on npm as [`@drunkcoding/agents-and-skills`](https://www.npmjs.com/pac
 | [`plugin-validator`](plugins/plugin-validator) | Orchestrated validator that checks every plugin's skills, agents, commands, and hooks for spec compliance — runs in parallel and proposes batched fixes. |
 | [`team-share`](plugins/team-share) | Onboarding helper that shares Claude plugin settings, scaffolds `CLAUDE.md` when missing, refreshes the Understand-Anything graph, and stages the resulting repo artifacts for review. |
 | [`auto-power`](plugins/auto-power) | Single-command hands-off pipeline that wraps `obra/superpowers`. Auto-answers safe clarifying questions during spec, then runs plan → arch+sec → impl → verify → review → ff-merge with no further touchpoints. Checkpointed and resumable. Escalates on substantive failures. |
+| [`multica-tool`](plugins/multica-tool) | Export, import, and sync Multica skills, agents, and squads between workspaces. |
 
 ## team-superpower v3
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drunkcoding/agents-and-skills",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Personal collection of Claude Code skills and agents, installable via `npx skills`.",
   "keywords": [
     "claude-code",

package/plugins/html-effectiveness/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "html-effectiveness",
   "displayName": "HTML Effectiveness Reports",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Generate self-contained interactive HTML reports from 20 upstream templates via a conversational agent.",
   "author": {
     "name": "Steven Hoang"

package/plugins/multica-tool/.claude-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "multica-tool",
+  "version": "0.0.33",
+  "description": "Export, import, and sync Multica skills, agents, and squads between workspaces via the multica CLI."
+}

package/plugins/multica-tool/agents/export.md

@@ -0,0 +1,17 @@
+---
+name: export
+description: Use when delegating a Multica export as a background task. Runs the multica-tool:export skill in its own context for long background migrations and returns the final JSON report.
+tools: Bash, Read, Skill
+---
+
+# Multica Export Executor
+
+Standalone executor for the `multica-tool:export` skill. Runs the export operation to completion and returns the final JSON report.
+
+## Behavior
+
+You are a standalone executor. Invoke the `multica-tool:export` skill with the arguments passed to you, run it to completion, and return the final JSON report. You are NOT part of a coordinated team.
+
+1. Invoke the `multica-tool:export` skill, forwarding all arguments received.
+2. Wait for the skill to complete.
+3. Return the final JSON report from the skill output.

package/plugins/multica-tool/agents/import.md

@@ -0,0 +1,17 @@
+---
+name: import
+description: Use when delegating a Multica import as a background task. Runs the multica-tool:import skill in its own context for long background migrations and returns the final JSON report.
+tools: Bash, Read, Skill
+---
+
+# Multica Import Executor
+
+Standalone executor for the `multica-tool:import` skill. Runs the import operation to completion and returns the final JSON report.
+
+## Behavior
+
+You are a standalone executor. Invoke the `multica-tool:import` skill with the arguments passed to you, run it to completion, and return the final JSON report. You are NOT part of a coordinated team.
+
+1. Invoke the `multica-tool:import` skill, forwarding all arguments received.
+2. Wait for the skill to complete.
+3. Return the final JSON report from the skill output.

package/plugins/multica-tool/agents/sync.md

@@ -0,0 +1,17 @@
+---
+name: sync
+description: Use when delegating a Multica sync as a background task. Runs the multica-tool:sync skill in its own context for long background migrations and returns the final JSON report.
+tools: Bash, Read, Skill
+---
+
+# Multica Sync Executor
+
+Standalone executor for the `multica-tool:sync` skill. Runs the sync operation to completion and returns the final JSON report.
+
+## Behavior
+
+You are a standalone executor. Invoke the `multica-tool:sync` skill with the arguments passed to you, run it to completion, and return the final JSON report. You are NOT part of a coordinated team.
+
+1. Invoke the `multica-tool:sync` skill, forwarding all arguments received.
+2. Wait for the skill to complete.
+3. Return the final JSON report from the skill output.

package/plugins/multica-tool/commands/export.md

@@ -0,0 +1,6 @@
+---
+description: Export Multica skills, agents, or squads to a local folder for backup or migration.
+argument-hint: [optional target path or options]
+---
+
+Invoke the `multica-tool:export` skill. Arguments: $ARGUMENTS

package/plugins/multica-tool/commands/import.md

@@ -0,0 +1,6 @@
+---
+description: Import a Multica export bundle into a target workspace, mapping source runtimes to target runtimes.
+argument-hint: [optional bundle path or options]
+---
+
+Invoke the `multica-tool:import` skill. Arguments: $ARGUMENTS

package/plugins/multica-tool/commands/sync.md

@@ -0,0 +1,6 @@
+---
+description: Sync a Multica skill, agent, or squad from one workspace to another in a single operation.
+argument-hint: [optional source/target workspace or options]
+---
+
+Invoke the `multica-tool:sync` skill. Arguments: $ARGUMENTS

package/plugins/multica-tool/scripts/build-dist.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// Generate OpenCode discovery artifacts from the canonical Claude Code plugin.
+// Source of truth: this plugin's skills/ + agents/ + commands/ + scripts/.
+// Output: dist/opencode/{skills,agents,commands}/ — copy into .opencode/ (project)
+// or ~/.config/opencode/ (global). Run: node plugins/multica-tool/scripts/build-dist.mjs
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync, copyFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLUGIN_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const REPO_ROOT = dirname(dirname(PLUGIN_ROOT));
+const OUT = join(REPO_ROOT, "dist", "opencode");
+const NAMES = ["export", "import", "sync"];
+// Runtime scripts shared by every skill (exclude this generator).
+const SCRIPTS = readdirSync(join(PLUGIN_ROOT, "scripts")).filter(
+  (f) => f.endsWith(".mjs") && f !== "build-dist.mjs",
+);
+
+// Naive frontmatter split — every source file uses single-line `key: value`.
+function parse(text) {
+  const m = text.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!m) throw new Error("missing frontmatter");
+  const fm = {};
+  for (const line of m[1].split("\n")) {
+    const i = line.indexOf(":");
+    if (i !== -1) fm[line.slice(0, i).trim()] = line.slice(i + 1).trim();
+  }
+  return { fm, body: m[2] };
+}
+
+const read = (...p) => readFileSync(join(PLUGIN_ROOT, ...p), "utf8");
+function write(rel, content) {
+  const abs = join(OUT, rel);
+  mkdirSync(dirname(abs), { recursive: true });
+  writeFileSync(abs, content);
+}
+// OpenCode resolves a skill's relative paths against the skill base dir it injects.
+const toOpencodePath = (s) => s.replace(/"\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\//g, '"scripts/');
+const stripSelfPrefix = (s) => s.replace(/multica-tool:/g, "");
+
+rmSync(OUT, { recursive: true, force: true });
+
+for (const name of NAMES) {
+  // Skill: keep prose, rewrite script path, drop Claude-only allowed-tools, bundle scripts.
+  const skill = parse(read("skills", name, "SKILL.md"));
+  const fm = `---\nname: ${skill.fm.name}\ndescription: ${skill.fm.description}\n---\n`;
+  write(`skills/${name}/SKILL.md`, fm + toOpencodePath(skill.body));
+  for (const s of SCRIPTS) {
+    mkdirSync(join(OUT, "skills", name, "scripts"), { recursive: true });
+    copyFileSync(join(PLUGIN_ROOT, "scripts", s), join(OUT, "skills", name, "scripts", s));
+  }
+
+  // Command: description only; body invokes the local (unprefixed) skill name.
+  const cmd = parse(read("commands", `${name}.md`));
+  write(`commands/${name}.md`, `---\ndescription: ${stripSelfPrefix(cmd.fm.description)}\n---\n${stripSelfPrefix(cmd.body)}`);
+
+  // Agent: tools -> permission.bash; body unprefixed.
+  const agent = parse(read("agents", `${name}.md`));
+  const head = `---\ndescription: ${stripSelfPrefix(agent.fm.description)}\nmode: subagent\npermission:\n  bash: allow\n---\n`;
+  write(`agents/${name}.md`, head + stripSelfPrefix(agent.body));
+}
+
+// Self-check: outputs must carry no Claude-only path/env and must bundle scripts.
+for (const name of NAMES) {
+  const md = readFileSync(join(OUT, "skills", name, "SKILL.md"), "utf8");
+  if (md.includes("CLAUDE_PLUGIN_ROOT") || md.includes("plugins/multica-tool"))
+    throw new Error(`leaked Claude path in ${name}/SKILL.md`);
+  for (const s of SCRIPTS) readFileSync(join(OUT, "skills", name, "scripts", s)); // throws if missing
+}
+
+console.log(`Wrote OpenCode artifacts for [${NAMES.join(", ")}] to ${OUT}`);

package/plugins/multica-tool/scripts/lib.mjs

@@ -0,0 +1,93 @@
+import { spawnSync } from "node:child_process";
+
+export function slugify(name) {
+  const s = String(name)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return s || "unnamed";
+}
+
+export function realExec(args) {
+  return spawnSync("multica", args, { encoding: "utf8" });
+}
+
+export function makeCli(exec, { workspaceId } = {}) {
+  function run(args) {
+    let full = args;
+    if (workspaceId) {
+      full = [...args, "--workspace-id", workspaceId];
+    }
+    const res = exec(full);
+    if (res.status !== 0) throw new Error(res.stderr?.trim() || `multica exited ${res.status}`);
+    return res.stdout;
+  }
+  function json(args) {
+    const fullArgs = workspaceId ? [...args, "--workspace-id", workspaceId, "--output", "json"] : [...args, "--output", "json"];
+    const res = exec(fullArgs);
+    if (res.status !== 0) throw new Error(res.stderr?.trim() || `multica exited ${res.status}`);
+    return JSON.parse(res.stdout);
+  }
+  return { run, json };
+}
+
+export function requireAuth(exec) {
+  const res = exec(["auth", "status"]);
+  if (res.status !== 0) throw new Error("Not authenticated. Run: multica login");
+}
+
+export function findByName(list, name) {
+  const hits = (list || []).filter((x) => x.name === name);
+  if (hits.length > 1) throw new Error(`Duplicate name "${name}" — refusing to guess`);
+  return hits[0] || null;
+}
+
+export function resolveWorkspaceId(cli, name) {
+  const list = cli.json(["workspace", "list"]);
+  const hits = list.filter((w) => w.name === name);
+  if (hits.length === 0) throw new Error(`Unknown workspace "${name}"`);
+  if (hits.length > 1) throw new Error(`Ambiguous workspace "${name}"`);
+  return hits[0].id;
+}
+
+export const listRuntimes = (cli) => cli.json(["runtime", "list"]);
+export const listSkills = (cli) => cli.json(["skill", "list"]);
+export const listAgents = (cli) => cli.json(["agent", "list"]);
+export const listSquads = (cli) => cli.json(["squad", "list"]);
+
+// Get-wrappers: the ONLY place that knows the raw CLI field names. They
+// return a stable camelCase shape so downstream code never sees snake_case.
+export function getSkill(cli, id) {
+  const s = cli.json(["skill", "get", id]);
+  return {
+    id: s.id, name: s.name, description: s.description,
+    content: s.content ?? "", config: s.config ?? {},
+    files: (s.files ?? []).map((f) => ({ path: f.path, content: f.content })),
+  };
+}
+
+export function getAgent(cli, id) {
+  const a = cli.json(["agent", "get", id]);
+  return {
+    id: a.id, name: a.name, description: a.description, instructions: a.instructions,
+    model: a.model, visibility: a.visibility,
+    maxConcurrentTasks: a.max_concurrent_tasks,
+    runtimeConfig: a.runtime_config,
+    customArgs: a.custom_args,
+    thinkingLevel: a.thinking_level,
+    runtimeId: a.runtime_id,
+    hasCustomEnv: a.has_custom_env,
+    mcpConfig: a.mcp_config,
+    skills: (a.skills ?? []).map((sk) => ({ id: sk.id, name: sk.name })),
+  };
+}
+
+export function getSquad(cli, id) {
+  const s = cli.json(["squad", "get", id]);
+  return { id: s.id, name: s.name, description: s.description, leaderId: s.leader_id };
+}
+
+export const getSquadMembers = (cli, id) =>
+  (cli.json(["squad", "member", "list", id]) ?? []).map((m) => ({
+    memberId: m.member_id, memberType: m.member_type, role: m.role || "member",
+  }));

package/plugins/multica-tool/scripts/multica-export.mjs

@@ -0,0 +1,136 @@
+import * as nodeFs from "node:fs";
+import { slugify, getSkill, getAgent, getSquad, getSquadMembers, makeCli, realExec, requireAuth, resolveWorkspaceId } from "./lib.mjs";
+
+const nonEmpty = (v) => v && typeof v === "object" && Object.keys(v).length > 0;
+
+export function redactAgent(a) {
+  // a is a normalized (camelCase) agent from getAgent.
+  const { id, hasCustomEnv, mcpConfig, skills, runtimeId, ...rest } = a;
+  const hadSecrets = !!hasCustomEnv || nonEmpty(mcpConfig);
+  return {
+    record: { ...rest, sourceRuntimeId: runtimeId, skillNames: [], hadSecrets },
+    hadSecrets,
+  };
+}
+
+export function buildManifest({ scope, sourceWorkspaceId, skills, agents, squad }) {
+  const seenSkills = new Map();
+  for (const s of skills) if (!seenSkills.has(s.name)) seenSkills.set(s.name, s);
+  const seenAgents = new Map();
+  for (const a of agents) if (!seenAgents.has(a.name)) seenAgents.set(a.name, a);
+  return {
+    version: "1",
+    scope,
+    sourceWorkspaceId,
+    skills: [...seenSkills.values()].map((s) => ({ name: s.name, dir: `skills/${slugify(s.name)}`, sourceId: s.sourceId })),
+    agents: [...seenAgents.values()].map((a) => ({ name: a.name, file: `agents/${slugify(a.name)}.json`, sourceRuntimeId: a.sourceRuntimeId, skillNames: a.skillNames, hadSecrets: !!a.hadSecrets })),
+    squads: squad ? [{ name: squad.name, file: `squads/${slugify(squad.name)}.json`, description: squad.description ?? "", leaderName: squad.leaderName, members: squad.members }] : [],
+  };
+}
+
+function collectSkill(cli, id, skills) {
+  const s = getSkill(cli, id);
+  if (!skills.has(s.name)) skills.set(s.name, s);
+  return s.name;
+}
+
+// Keyed by agent id (so squad leaderId/memberId resolve to names). Stores the
+// normalized agent, its redaction result, and its skill names.
+function collectAgent(cli, id, agentsById, skills) {
+  if (agentsById.has(id)) return agentsById.get(id);
+  const a = getAgent(cli, id);
+  const skillNames = a.skills.map((sk) => collectSkill(cli, sk.id, skills));
+  const red = redactAgent(a);
+  const entry = { raw: a, red, skillNames };
+  agentsById.set(id, entry);
+  return entry;
+}
+
+export function exportResource({ cli, scope, ids, outDir, sourceWorkspaceId, fs = nodeFs }) {
+  const skills = new Map();       // name -> normalized skill
+  const agentsById = new Map();   // id   -> { raw, red, skillNames }
+  let squad = null;
+
+  if (scope === "skill") collectSkill(cli, ids.skillId, skills);
+  if (scope === "agent") collectAgent(cli, ids.agentId, agentsById, skills);
+  if (scope === "squad") {
+    const sq = getSquad(cli, ids.squadId);
+    const members = getSquadMembers(cli, ids.squadId).filter((m) => m.memberType === "agent");
+    for (const m of members) collectAgent(cli, m.memberId, agentsById, skills);
+    if (!agentsById.has(sq.leaderId)) collectAgent(cli, sq.leaderId, agentsById, skills);
+    const nameOf = (id) => agentsById.get(id)?.raw.name;
+    squad = {
+      name: sq.name,
+      description: sq.description,
+      leaderName: nameOf(sq.leaderId),
+      members: members.map((m) => ({ agentName: nameOf(m.memberId), role: m.role })),
+    };
+  }
+
+  const manifest = buildManifest({
+    scope, sourceWorkspaceId,
+    skills: [...skills.values()].map((s) => ({ name: s.name, sourceId: s.id })),
+    agents: [...agentsById.values()].map((a) => ({ name: a.raw.name, sourceRuntimeId: a.raw.runtimeId, skillNames: a.skillNames, hadSecrets: a.red.hadSecrets })),
+    squad,
+  });
+
+  const warnings = [];
+  fs.mkdirSync(outDir, { recursive: true });
+
+  for (const entry of manifest.skills) {
+    const s = skills.get(entry.name);
+    const dir = `${outDir}/${entry.dir}`;
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(`${dir}/SKILL.md`, s.content ?? "");
+    fs.writeFileSync(`${dir}/config.json`, JSON.stringify(s.config ?? {}, null, 2));
+    for (const f of s.files ?? []) fs.writeFileSync(`${dir}/${f.path}`, f.content ?? "");
+  }
+  // Index agent entries by name for the manifest writing loop.
+  const agentByName = new Map([...agentsById.values()].map((a) => [a.raw.name, a]));
+  for (const entry of manifest.agents) {
+    const { raw, red, skillNames } = agentByName.get(entry.name);
+    const record = { ...red.record, skillNames };
+    if (red.hadSecrets) warnings.push(raw.name);
+    fs.mkdirSync(`${outDir}/agents`, { recursive: true });
+    fs.writeFileSync(`${outDir}/${entry.file}`, JSON.stringify(record, null, 2));
+  }
+  for (const entry of manifest.squads) {
+    fs.mkdirSync(`${outDir}/squads`, { recursive: true });
+    fs.writeFileSync(`${outDir}/${entry.file}`, JSON.stringify(entry, null, 2));
+  }
+  fs.writeFileSync(`${outDir}/manifest.json`, JSON.stringify(manifest, null, 2));
+  return { manifest, warnings };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const get = (flag) => { const i = args.indexOf(flag); return i !== -1 ? args[i + 1] : null; };
+
+  const scope     = get("--scope");
+  const id        = get("--id");
+  const out       = get("--out");
+  const workspace = get("--workspace"); // optional: source workspace name
+
+  if (!scope || !id || !out) {
+    console.error("Usage: multica-export.mjs --scope <skill|agent|squad> --id <id> --out <dir> [--workspace <name>]");
+    process.exit(1);
+  }
+
+  requireAuth(realExec);
+
+  let sourceWorkspaceId = "";
+  const resolver = makeCli(realExec);
+  if (workspace) sourceWorkspaceId = resolveWorkspaceId(resolver, workspace);
+  const cli = workspace ? makeCli(realExec, { workspaceId: sourceWorkspaceId }) : resolver;
+
+  const ids = {};
+  if (scope === "skill")       ids.skillId  = id;
+  else if (scope === "agent")  ids.agentId  = id;
+  else if (scope === "squad")  ids.squadId  = id;
+  else { console.error(`Unknown scope "${scope}" — use skill|agent|squad`); process.exit(1); }
+
+  const result = exportResource({ cli, scope, ids, outDir: out, sourceWorkspaceId, fs: nodeFs });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main();

package/plugins/multica-tool/scripts/multica-import.mjs

@@ -0,0 +1,146 @@
+import * as nodeFs from "node:fs";
+import { listSkills, listAgents, listSquads, findByName, makeCli, realExec, requireAuth, resolveWorkspaceId } from "./lib.mjs";
+
+export function importSkills({ cli, manifest, dir, fs = nodeFs }) {
+  const idMap = new Map();
+  let created = 0, updated = 0;
+  const existing = listSkills(cli);
+
+  for (const s of manifest.skills) {
+    const sdir = dir === "." ? s.dir : `${dir}/${s.dir}`;
+    const contentPath = `${sdir}/SKILL.md`;
+    const configPath = `${sdir}/config.json`;
+    const config = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "{}";
+    const match = findByName(existing, s.name);
+    let id;
+    if (match) {
+      cli.run(["skill", "update", match.id, "--content-file", contentPath, "--config", config]);
+      id = match.id; updated++;
+    } else {
+      const out = cli.run(["skill", "create", "--name", s.name, "--content-file", contentPath, "--config", config]);
+      id = JSON.parse(out).id; created++;
+    }
+    idMap.set(s.name, id);
+    // upsert extra files (everything except SKILL.md and config.json)
+    for (const f of fs.readdirSync(sdir)) {
+      if (f === "SKILL.md" || f === "config.json") continue;
+      cli.run(["skill", "files", "upsert", id, "--path", f, "--content-file", `${sdir}/${f}`]);
+    }
+  }
+  return { idMap, created, updated };
+}
+
+export function importAgents({ cli, manifest, dir, skillIdMap, runtimeMap, fs = nodeFs }) {
+  const idMap = new Map();
+  let created = 0, updated = 0;
+  const existing = listAgents(cli);
+
+  for (const a of manifest.agents) {
+    const rec = JSON.parse(fs.readFileSync(`${dir}/${a.file}`, "utf8"));
+    const targetRuntime = runtimeMap.get(rec.sourceRuntimeId);
+    if (!targetRuntime) throw new Error(`Unmapped runtime "${rec.sourceRuntimeId}" for agent "${rec.name}"`);
+    // Only pass optional flags when present — `--model ""` would CLEAR the model.
+    const common = [
+      "--visibility", rec.visibility ?? "private",
+      "--max-concurrent-tasks", String(rec.maxConcurrentTasks ?? 6),
+    ];
+    if (rec.instructions) common.push("--instructions", rec.instructions);
+    if (rec.model) common.push("--model", rec.model);
+    if (rec.thinkingLevel) common.push("--thinking-level", rec.thinkingLevel);
+    if (rec.runtimeConfig && Object.keys(rec.runtimeConfig).length) common.push("--runtime-config", JSON.stringify(rec.runtimeConfig));
+    if (Array.isArray(rec.customArgs) && rec.customArgs.length) common.push("--custom-args", JSON.stringify(rec.customArgs));
+    const match = findByName(existing, rec.name);
+    let id;
+    if (match) {
+      cli.run(["agent", "update", match.id, "--runtime-id", targetRuntime, ...common]);
+      id = match.id; updated++;
+    } else {
+      const out = cli.run(["agent", "create", "--name", rec.name, "--runtime-id", targetRuntime, ...common]);
+      id = JSON.parse(out).id; created++;
+    }
+    idMap.set(rec.name, id);
+    const skillIds = (rec.skillNames ?? []).map((n) => skillIdMap.get(n)).filter(Boolean);
+    cli.run(["agent", "skills", "set", id, "--skill-ids", skillIds.join(",")]);
+  }
+  return { idMap, created, updated };
+}
+
+export function importSquad({ cli, squad, agentIdMap }) {
+  const existing = listSquads(cli);
+  const leaderId = agentIdMap.get(squad.leaderName);
+  const match = findByName(existing, squad.name);
+  let id, created = 0, updated = 0;
+  if (match) {
+    cli.run(["squad", "update", match.id, "--leader", leaderId, "--description", squad.description ?? ""]);
+    id = match.id; updated++;
+  } else {
+    const out = cli.run(["squad", "create", "--name", squad.name, "--leader", leaderId, "--description", squad.description ?? ""]);
+    id = JSON.parse(out).id; created++;
+  }
+  for (const m of squad.members) {
+    if (m.agentName === squad.leaderName) continue;
+    cli.run(["squad", "member", "add", id, "--member-id", agentIdMap.get(m.agentName), "--role", m.role, "--type", "agent"]);
+  }
+  return { newId: id, created, updated };
+}
+
+export function collectSourceRuntimes(manifest) {
+  return [...new Set((manifest.agents ?? []).map((a) => a.sourceRuntimeId).filter(Boolean))];
+}
+
+export function importBundle({ cli, dir, runtimeMap, fs = nodeFs }) {
+  const manifest = JSON.parse(fs.readFileSync(`${dir}/manifest.json`, "utf8"));
+  const missing = collectSourceRuntimes(manifest).filter((r) => !runtimeMap.has(r));
+  if (missing.length) throw new Error(`Unmapped runtimes: ${missing.join(", ")} — aborting before any write`);
+
+  const skillRes = importSkills({ cli, manifest, dir, fs });
+  const agentRes = importAgents({ cli, manifest, dir, skillIdMap: skillRes.idMap, runtimeMap, fs });
+  let squadRes = { newId: null, created: 0, updated: 0 };
+  if (manifest.squads?.length) squadRes = importSquad({ cli, squad: manifest.squads[0], agentIdMap: agentRes.idMap });
+
+  return {
+    created: { skills: skillRes.created, agents: agentRes.created, squads: squadRes.created },
+    updated: { skills: skillRes.updated, agents: agentRes.updated, squads: squadRes.updated },
+    skillIdMap: Object.fromEntries(skillRes.idMap),
+    agentIdMap: Object.fromEntries(agentRes.idMap),
+    squadId: squadRes.newId,
+    secretsReminder: (manifest.agents ?? []).filter((a) => a.hadSecrets).map((a) => a.name),
+  };
+}
+
+function parseRuntimeMap(raw) {
+  // Parse "srcId1=dstId1,srcId2=dstId2" into a Map.
+  const map = new Map();
+  if (!raw) return map;
+  for (const pair of raw.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) continue;
+    map.set(pair.slice(0, eq).trim(), pair.slice(eq + 1).trim());
+  }
+  return map;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const get = (flag) => { const i = args.indexOf(flag); return i !== -1 ? args[i + 1] : null; };
+
+  const dir       = get("--dir");
+  const workspace = get("--workspace");
+  const rawMap    = get("--runtime-map");
+
+  if (!dir || !workspace) {
+    console.error("Usage: multica-import.mjs --dir <folder> --workspace <name> [--runtime-map <src=dst,...>]");
+    process.exit(1);
+  }
+
+  requireAuth(realExec);
+  const resolver  = makeCli(realExec);
+  const wsId      = resolveWorkspaceId(resolver, workspace);
+  const cli       = makeCli(realExec, { workspaceId: wsId });
+  const runtimeMap = parseRuntimeMap(rawMap);
+
+  const result = importBundle({ cli, dir, runtimeMap, fs: nodeFs });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main();

package/plugins/multica-tool/scripts/multica-sync.mjs

@@ -0,0 +1,66 @@
+import * as nodeFs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { makeCli, resolveWorkspaceId, findByName, listSkills, listAgents, listSquads, realExec, requireAuth } from "./lib.mjs";
+import { exportResource } from "./multica-export.mjs";
+import { importBundle } from "./multica-import.mjs";
+
+export function resolveScopeId(cli, type, name) {
+  const lists = { skill: listSkills, agent: listAgents, squad: listSquads };
+  if (!lists[type]) throw new Error(`Unknown type "${type}" (skill|agent|squad)`);
+  const match = findByName(lists[type](cli), name);
+  if (!match) throw new Error(`Unknown ${type} "${name}" in source workspace`);
+  const key = { skill: "skillId", agent: "agentId", squad: "squadId" }[type];
+  return { scope: type, ids: { [key]: match.id } };
+}
+
+export function sync({ exec, type, name, srcWsName, destWsName, tmpDir, runtimeMap, fs = nodeFs }) {
+  const resolver = makeCli(exec);                       // no ws — for workspace list
+  const srcId = resolveWorkspaceId(resolver, srcWsName);
+  const destId = resolveWorkspaceId(resolver, destWsName);
+  const srcCli = makeCli(exec, { workspaceId: srcId });
+  const destCli = makeCli(exec, { workspaceId: destId });
+
+  const { scope, ids } = resolveScopeId(srcCli, type, name);
+  exportResource({ cli: srcCli, scope, ids, outDir: tmpDir, sourceWorkspaceId: srcId, fs });
+  return importBundle({ cli: destCli, dir: tmpDir, runtimeMap, fs });
+}
+
+function parseRuntimeMap(raw) {
+  const map = new Map();
+  if (!raw) return map;
+  for (const pair of raw.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) continue;
+    map.set(pair.slice(0, eq).trim(), pair.slice(eq + 1).trim());
+  }
+  return map;
+}
+
+function main() {
+  // Usage: multica-sync.mjs <type> <name> from <src-ws> <dest-ws> [--runtime-map <src=dst,...>]
+  const args = process.argv.slice(2);
+  const get = (flag) => { const i = args.indexOf(flag); return i !== -1 ? args[i + 1] : null; };
+
+  // Positional: type name from srcWs destWs
+  const [type, name, _from, srcWsName, destWsName] = args;
+  const rawMap = get("--runtime-map");
+
+  if (!type || !name || _from !== "from" || !srcWsName || !destWsName) {
+    console.error("Usage: multica-sync.mjs <type> <name> from <src-ws> <dest-ws> [--runtime-map <src=dst,...>]");
+    process.exit(1);
+  }
+
+  requireAuth(realExec);
+  const runtimeMap = parseRuntimeMap(rawMap);
+  const tmpDir = nodeFs.mkdtempSync(path.join(os.tmpdir(), "multica-sync-"));
+
+  try {
+    const result = sync({ exec: realExec, type, name, srcWsName, destWsName, tmpDir, runtimeMap, fs: nodeFs });
+    console.log(JSON.stringify(result, null, 2));
+  } finally {
+    nodeFs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) main();

package/plugins/multica-tool/skills/export/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: export
+description: Use when the user wants to export Multica skills, agents, or squads to a local folder for backup, version control, or cross-workspace migration.
+allowed-tools: Bash, Read
+---
+
+# export
+
+Export a Multica resource (skill, agent, or squad) to a local bundle directory.
+
+## Step 1 — Verify authentication
+
+Run the export script; it calls `multica auth status` internally and exits with an error message if unauthenticated:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/multica-export.mjs" --help 2>&1 || true
+```
+
+If `multica login` is required, surface that message verbatim and stop.
+
+## Step 2 — Determine scope and resource ID
+
+If the user named a specific resource and type (`skill`, `agent`, or `squad`), use those directly.
+
+Otherwise, list available resources for the chosen type and present a pick list:
+
+```bash
+multica <type> list --output json
+```
+
+Ask the user to select a resource by name. Resolve its `id` from the list output.
+
+## Step 3 — Determine output directory
+
+If the user specified an output directory, use it. Otherwise default to:
+
+```
+./multica-export-<slug>-<type>
+```
+
+where `<slug>` is a lowercased, hyphenated form of the resource name.
+
+## Step 4 — Run the export
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/multica-export.mjs" \
+  --scope <type> \
+  --id <id> \
+  --out <dir> \
+  [--workspace <workspace-name>]
+```
+
+The script writes `manifest.json`, skill SKILL.md files, agent JSON files, and squad JSON files into `<dir>`.
+
+## Step 5 — Report results
+
+Parse the JSON output from the script and report:
+
+- Directory written to.
+- Count of skills, agents, and squads exported.
+- If `warnings` is non-empty, surface every agent name verbatim with this message: "WARNING: the following agents had custom environment variables or MCP config that were NOT exported — re-add secrets manually after import: `<agent-name>`."

package/plugins/multica-tool/skills/import/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: import
+description: Use when the user wants to import a Multica export bundle into a target workspace, mapping source runtimes to target runtimes before writing any resources.
+allowed-tools: Bash, Read
+---
+
+# import
+
+Import a local Multica bundle (produced by the export skill) into a target workspace.
+
+## Step 1 — Confirm the target workspace
+
+Ask the user to confirm the name of the target workspace if not already stated. You will need the exact workspace name as registered in Multica.
+
+## Step 2 — Plan pass: read the bundle and collect unmapped runtimes
+
+Read the manifest to discover which source runtimes are referenced:
+
+```bash
+cat <folder>/manifest.json
+```
+
+Collect each distinct `sourceRuntimeId` from the `agents` array.
+
+List runtimes available in the target workspace:
+
+```bash
+multica runtime list --output json
+```
+
+For each distinct `sourceRuntimeId`, ask the user to pick a matching target runtime by name or ID. Build a mapping in the form `srcId=dstId`. If any source runtime has no mapping selected, abort and explain which IDs remain unmapped — do not write any resources.
+
+## Step 3 — Run the import
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/multica-import.mjs" \
+  --dir <folder> \
+  --workspace <workspace-name> \
+  --runtime-map <srcId1=dstId1,srcId2=dstId2,...>
+```
+
+## Step 4 — Report results
+
+Parse the JSON output and report:
+
+- Created and updated counts for skills, agents, and squads.
+- Name-to-ID maps for skills and agents (`skillIdMap`, `agentIdMap`).
+- Squad ID if a squad was imported.
+- If `secretsReminder` is non-empty, surface every agent name verbatim with: "WARNING: the following agents had custom environment variables or MCP config that were NOT exported — re-add secrets manually in the Multica UI: `<agent-name>`."

package/plugins/multica-tool/skills/sync/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: sync
+description: Use when the user wants to sync a Multica skill, agent, or squad from one workspace to another in a single operation.
+allowed-tools: Bash, Read
+---
+
+# sync
+
+Copy a Multica resource from a source workspace to a destination workspace.
+
+## Step 1 — Parse the sync request
+
+Expect the user's request in the form:
+
+```
+sync <type> <name> from <src-ws> to <dest-ws>
+```
+
+Where `<type>` is `skill`, `agent`, or `squad`; `<name>` is the resource name; `<src-ws>` and `<dest-ws>` are workspace names registered in Multica.
+
+## Step 2 — Build the runtime map
+
+List runtimes available in the destination workspace:
+
+```bash
+multica runtime list --output json
+```
+
+Using the source workspace, fetch the resource to discover which `sourceRuntimeId` values are referenced (for agents and squads). For each distinct `sourceRuntimeId`, ask the user to select a matching target runtime by name or ID. Build a mapping in the form `srcId=dstId`. If any source runtime has no mapping, abort before running the sync.
+
+For skills (which have no runtime dependency), an empty runtime map is acceptable.
+
+## Step 3 — Run the sync
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/multica-sync.mjs" \
+  <type> <name> from <src-ws> <dest-ws> \
+  [--runtime-map <srcId1=dstId1,srcId2=dstId2,...>]
+```
+
+The script exports to a temporary directory, imports into the destination workspace, then cleans up the temporary files automatically.
+
+## Step 4 — Report results
+
+Parse the JSON output and report:
+
+- Created and updated counts for skills, agents, and squads.
+- Name-to-ID maps (`skillIdMap`, `agentIdMap`).
+- Squad ID if a squad was synced.
+- If `secretsReminder` is non-empty, surface every agent name verbatim with: "WARNING: the following agents had custom environment variables or MCP config that were NOT exported — re-add secrets manually in the Multica UI: `<agent-name>`."

package/plugins/plugin-validator/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "plugin-validator",
   "displayName": "Plugin Validator",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Orchestrated validator for Claude Code plugins — validates skills, agents, commands, and hooks across every plugin under plugins/**.",
   "author": {
     "name": "Steven Hoang"

package/plugins/team-share/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "team-share",
   "displayName": "Team Share",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Onboard your team with an interactive setup menu: install CodeGraph, build the Understand-Anything knowledge graph, and share Claude Code settings — run any combination, all idempotent.",
   "author": {
     "name": "Steven Hoang"

package/plugins/tech-graph/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "tech-graph",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "Step-by-step wizard for generating technical diagrams as SVG+PNG.",
   "author": {
     "name": "steven"