@drunkcoding/agents-and-skills 0.0.41 → 0.0.43

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.41",
+      "version": "0.0.43",
       "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.41",
+      "version": "0.0.43",
       "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.41",
+      "version": "0.0.43",
       "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.41",
+      "version": "0.0.43",
       "category": "tooling",
       "keywords": [
         "onboarding",
@@ -73,7 +73,7 @@
       "name": "multica-tool",
       "source": "./plugins/multica-tool",
       "description": "Export, import, and sync Multica skills, agents, and squads between workspaces.",
-      "version": "0.0.41",
+      "version": "0.0.43",
       "category": "workflow",
       "keywords": [
         "multica",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drunkcoding/agents-and-skills",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "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.41",
+  "version": "0.0.43",
   "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

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

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

@@ -127,3 +127,27 @@ export const getProjectResources = (cli, id) =>
   (cli.json(["project", "resource", "list", id]) ?? []).map((r) => ({
     resource_type: r.resource_type, resource_ref: r.resource_ref, label: r.label ?? null,
   }));
+
+export const listAutopilots = (cli) => cli.json(["autopilot", "list"]).autopilots ?? [];
+
+// `autopilot get` wraps the record as {autopilot, collaborators, triggers} — only
+// autopilot + triggers are portable; collaborators/can_write/can_manage_access are
+// caller-relative and never bundled. `priority` is accepted by `autopilot
+// create`/`update` but never present in this response (verified live) — kept as a
+// field anyway so this starts round-tripping automatically if the API adds it.
+export function getAutopilot(cli, id) {
+  const r = cli.json(["autopilot", "get", id]);
+  const a = r.autopilot;
+  return {
+    id: a.id, title: a.title, description: a.description ?? "",
+    execution_mode: a.execution_mode, issue_title_template: a.issue_title_template ?? null,
+    priority: a.priority ?? null,
+    project_id: a.project_id ?? null,
+    assignee_id: a.assignee_id, assignee_type: a.assignee_type,
+    subscribers: (a.subscribers ?? []).map((s) => ({ user_id: s.user_id, user_type: s.user_type })),
+    triggers: (r.triggers ?? []).map((t) => ({
+      kind: t.kind, label: t.label ?? null, enabled: !!t.enabled,
+      cron_expression: t.cron_expression ?? null, timezone: t.timezone ?? null,
+    })),
+  };
+}

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

@@ -1,7 +1,7 @@
 import * as nodeFs from "node:fs";
 import { spawnSync } from "node:child_process";
 import { dirname } from "node:path";
-import { slugify, getSkill, getAgent, getAgentCustomEnv, getSquad, getSquadMembers, listRuntimes, listSkills, listAgents, listSquads, listProjects, getProject, getProjectResources, makeCli, realExec, requireAuth, resolveWorkspaceId } from "./lib.mjs";
+import { slugify, getSkill, getAgent, getAgentCustomEnv, getSquad, getSquadMembers, listRuntimes, listSkills, listAgents, listSquads, listProjects, getProject, getProjectResources, listWorkspaceMembers, getAutopilot, makeCli, realExec, requireAuth, resolveWorkspaceId } from "./lib.mjs";
 
 const nonEmpty = (v) => v && typeof v === "object" && Object.keys(v).length > 0;
 
@@ -57,7 +57,7 @@ export function redactAgent(a) {
   };
 }
 
-export function buildManifest({ scope, sourceWorkspaceId, skills, agents, squads, projects }) {
+export function buildManifest({ scope, sourceWorkspaceId, skills, agents, squads, projects, autopilots }) {
   const seenSkills = new Map();
   for (const s of skills) if (!seenSkills.has(s.name)) seenSkills.set(s.name, s);
   const seenAgents = new Map();
@@ -81,6 +81,11 @@ export function buildManifest({ scope, sourceWorkspaceId, skills, agents, squads
       title: p.title, file: `projects/${slugify(p.title)}.json`,
       source_id: p.source_id, lead_name: p.lead_name ?? null, lead_type: p.lead_type ?? null,
     })),
+    autopilots: (autopilots ?? []).map((ap) => ({
+      title: ap.title, file: `autopilots/${slugify(ap.title)}.json`, source_id: ap.source_id,
+      assignee_type: ap.assignee_type, assignee_name: ap.assignee_name,
+      project_title: ap.project_title, had_webhook_trigger: ap.had_webhook_trigger,
+    })),
   };
 }
 
@@ -133,6 +138,7 @@ export function exportResource({ cli, scope, ids, outDir, sourceWorkspaceId, fs
   const agentsById = new Map();   // id   -> { raw, red, skill_names }
   const squads = [];
   const projects = [];
+  const autopilots = [];
   // Lazy + memoized: only fetched when an agent is actually collected (skips
   // the extra CLI call on skill-only exports).
   let providerById = null;
@@ -152,11 +158,46 @@ export function exportResource({ cli, scope, ids, outDir, sourceWorkspaceId, fs
     };
   }
 
+  // Collect a single autopilot: its assignee (agent, or squad + members + skills)
+  // and, when present, the destination-portable project title / subscriber names.
+  // Webhook trigger secrets (url/token) are never read into the bundle — only
+  // kind/label/enabled, matching the existing agent MCP/env redaction pattern.
+  function collectOneAutopilot(autopilotId) {
+    const ap = getAutopilot(cli, autopilotId);
+    let assignee_name = null;
+    if (ap.assignee_type === "agent") {
+      assignee_name = collectAgent(cli, ap.assignee_id, agentsById, skills, getProviderById()).raw.name;
+    } else if (ap.assignee_type === "squad") {
+      const sq = collectOneSquad(ap.assignee_id);
+      squads.push(sq);
+      assignee_name = sq.name;
+    }
+    let project_title = null;
+    if (ap.project_id) {
+      try { project_title = getProject(cli, ap.project_id).title; } catch { project_title = null; }
+    }
+    let subscriber_names = [];
+    if (ap.subscribers.length) {
+      const members = listWorkspaceMembers(cli);
+      subscriber_names = ap.subscribers.map((s) => members.find((m) => m.user_id === s.user_id)?.name).filter(Boolean);
+    }
+    return {
+      title: ap.title, source_id: ap.id, description: ap.description,
+      execution_mode: ap.execution_mode, issue_title_template: ap.issue_title_template,
+      priority: ap.priority, project_title, assignee_type: ap.assignee_type, assignee_name,
+      subscriber_names, had_webhook_trigger: ap.triggers.some((t) => t.kind === "webhook"),
+      triggers: ap.triggers.map((t) => t.kind === "webhook"
+        ? { kind: "webhook", label: t.label, enabled: t.enabled }
+        : { kind: t.kind, label: t.label, enabled: t.enabled, cron_expression: t.cron_expression, timezone: t.timezone }),
+    };
+  }
+
   if (scope === "skill") collectSkill(cli, ids.skillId, skills);
   else if (scope === "agent") collectAgent(cli, ids.agentId, agentsById, skills, getProviderById());
   else if (scope === "squad") squads.push(collectOneSquad(ids.squadId));
   else if (scope === "project") projects.push(collectProject(cli, ids.projectId, agentsById, skills, getProviderById()));
   else if (scope === "projects") for (const p of listProjects(cli)) projects.push(collectProject(cli, p.id, agentsById, skills, getProviderById()));
+  else if (scope === "autopilot") autopilots.push(collectOneAutopilot(ids.autopilotId));
   else if (scope === "all") {
     for (const s of listSkills(cli)) collectSkill(cli, s.id, skills);
     for (const a of listAgents(cli)) collectAgent(cli, a.id, agentsById, skills, getProviderById());
@@ -183,6 +224,7 @@ export function exportResource({ cli, scope, ids, outDir, sourceWorkspaceId, fs
     agents: [...agentsById.values()].map((a) => ({ name: a.raw.name, source_id: a.raw.id, source_runtime_id: a.raw.runtime_id, source_runtime_provider: a.raw.source_runtime_provider, skill_names: a.skill_names, had_secrets: a.red.hadSecrets })),
     squads,
     projects,
+    autopilots,
   });
 
   const warnings = [];
@@ -241,8 +283,16 @@ export function exportResource({ cli, scope, ids, outDir, sourceWorkspaceId, fs
     fs.mkdirSync(`${outDir}/projects`, { recursive: true });
     fs.writeFileSync(`${outDir}/${entry.file}`, JSON.stringify(projectByTitle.get(entry.title), null, 2));
   }
+  const autopilotByTitle = new Map(autopilots.map((a) => [a.title, a]));
+  for (const entry of manifest.autopilots) {
+    fs.mkdirSync(`${outDir}/autopilots`, { recursive: true });
+    fs.writeFileSync(`${outDir}/${entry.file}`, JSON.stringify(autopilotByTitle.get(entry.title), null, 2));
+  }
   fs.writeFileSync(`${outDir}/manifest.json`, JSON.stringify(manifest, null, 2));
-  return { manifest, warnings, pruned_skills };
+  return {
+    manifest, warnings, pruned_skills,
+    autopilotWebhookTriggers: autopilots.filter((a) => a.had_webhook_trigger).map((a) => a.title),
+  };
 }
 
 function main() {
@@ -255,7 +305,7 @@ function main() {
   const workspace = get("--workspace"); // optional: source workspace name
 
   if (!scope || !out || (scope !== "all" && scope !== "projects" && !id)) {
-    console.error("Usage: multica-export.mjs --scope <skill|agent|squad|project|projects|all> --id <id> --out <dir> [--workspace <name>]  (--id not needed for --scope all|projects)");
+    console.error("Usage: multica-export.mjs --scope <skill|agent|squad|project|projects|autopilot|all> --id <id> --out <dir> [--workspace <name>]  (--id not needed for --scope all|projects)");
     process.exit(1);
   }
 
@@ -272,8 +322,9 @@ function main() {
   else if (scope === "squad")  ids.squadId  = id;
   else if (scope === "project")  ids.projectId = id;
   else if (scope === "projects") { /* all projects — no id */ }
+  else if (scope === "autopilot") ids.autopilotId = id;
   else if (scope === "all")    { /* whole workspace — no id */ }
-  else { console.error(`Unknown scope "${scope}" — use skill|agent|squad|project|projects|all`); process.exit(1); }
+  else { console.error(`Unknown scope "${scope}" — use skill|agent|squad|project|projects|autopilot|all`); process.exit(1); }
 
   const result = exportResource({ cli, scope, ids, outDir: out, sourceWorkspaceId, fs: nodeFs });
   console.log(JSON.stringify(result, null, 2));

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

@@ -1,7 +1,7 @@
 import * as nodeFs from "node:fs";
-import { listSkills, listAgents, listSquads, listRuntimes, listWorkspaceMembers, getSquadMembers, findByName, makeCli, realExec, requireAuth, resolveWorkspaceId, listProjects, getProjectResources, findByTitle } from "./lib.mjs";
+import { listSkills, listAgents, listSquads, listRuntimes, listWorkspaceMembers, getSquadMembers, findByName, makeCli, realExec, requireAuth, resolveWorkspaceId, listProjects, getProjectResources, findByTitle, listAutopilots, getAutopilot } from "./lib.mjs";
 
-// User-facing selectable types are agents/squads/projects; skills follow agents.
+// User-facing selectable types are agents/squads/projects/autopilots; skills follow agents.
 export function parseInclude(raw) {
   const set = new Set((raw ? raw.split(",") : ["agents", "squads"]).map((s) => s.trim()).filter(Boolean));
   if (set.has("agents")) set.add("skills");
@@ -298,6 +298,99 @@ export function importProjects({ cli, manifest, dir, agentIdMap, fs = nodeFs })
   return { idMap, created, updated, priorityUnsupported, resourcesUnsupported, leadUnresolved };
 }
 
+// `autopilot create`/`update` only accept `--agent` (name or ID) — there is no
+// `--squad` flag, even though the data model supports squad-assigned autopilots
+// (dispatch resolves to the squad leader). A squad assignee, or an agent name not
+// resolvable in this import or the destination, is reported up front so the whole
+// import aborts before any write — mirroring the unmapped-runtime guard above,
+// never silently dropped or reassigned to the wrong agent.
+function unresolvedAutopilotAssignees({ cli, manifest, recs, agentIdMap }) {
+  let destAgentNames = null;
+  const agentResolvable = (name) => agentIdMap.has(name) || (destAgentNames ??= new Set(listAgents(cli).map((a) => a.name))).has(name);
+  const unresolved = [];
+  for (const rec of recs) {
+    if (rec.assignee_type === "squad") {
+      unresolved.push(`"${rec.title}" → squad "${rec.assignee_name}" (the multica CLI has no command to assign a squad to an autopilot)`);
+    } else if (!agentResolvable(rec.assignee_name)) {
+      unresolved.push(`"${rec.title}" → agent "${rec.assignee_name}" (not found in this import or the destination workspace)`);
+    }
+  }
+  return unresolved;
+}
+
+export function importAutopilots({ cli, manifest, dir, agentIdMap, fs = nodeFs }) {
+  const entries = manifest.autopilots ?? [];
+  const recs = entries.map((entry) => JSON.parse(fs.readFileSync(`${dir}/${entry.file}`, "utf8")));
+
+  const unresolved = unresolvedAutopilotAssignees({ cli, manifest, recs, agentIdMap });
+  if (unresolved.length) {
+    throw new Error(`Unresolved autopilot assignees: ${unresolved.join(", ")} — aborting before any write`);
+  }
+
+  const idMap = new Map();
+  let created = 0, updated = 0;
+  const projectUnresolved = [], subscribersUnresolved = [], priorityNotCaptured = [], webhookReissued = [];
+  const existing = listAutopilots(cli);
+  let destProjects = null;
+  const resolveProjectId = (title) => (destProjects ??= listProjects(cli)).find((p) => p.title === title)?.id ?? null;
+  let destMembers = null;
+  const memberExists = (name) => (destMembers ??= listWorkspaceMembers(cli)).some((m) => m.name === name);
+
+  for (const rec of recs) {
+    const common = [];
+    if (rec.description) common.push("--description", rec.description);
+    if (rec.issue_title_template) common.push("--issue-title-template", rec.issue_title_template);
+    // priority is never present today — the multica CLI/API accepts it on write but
+    // never returns it on read, so export can't capture the source's real value.
+    if (rec.priority && rec.priority !== "none") common.push("--priority", rec.priority);
+    else priorityNotCaptured.push(rec.title);
+
+    if (rec.project_title) {
+      const projectId = resolveProjectId(rec.project_title);
+      if (projectId) common.push("--project", projectId);
+      else projectUnresolved.push(rec.title);
+    }
+
+    const wantedSubscribers = rec.subscriber_names ?? [];
+    const resolvableSubscribers = wantedSubscribers.filter(memberExists);
+    subscribersUnresolved.push(...wantedSubscribers.filter((n) => !memberExists(n)).map((n) => `${rec.title}:${n}`));
+    if (resolvableSubscribers.length) common.push(...resolvableSubscribers.flatMap((n) => ["--subscriber", n]));
+
+    const match = findByTitle(existing, rec.title);
+    let id;
+    if (match) {
+      cli.run(["autopilot", "update", match.id, "--agent", rec.assignee_name, "--mode", rec.execution_mode, ...common]);
+      id = match.id; updated++;
+    } else {
+      const out = cli.run(["autopilot", "create", "--title", rec.title, "--agent", rec.assignee_name, "--mode", rec.execution_mode, ...common]);
+      id = JSON.parse(out).id;
+      // Always arrives paused, regardless of source status — activation is a
+      // deliberate follow-up action, never automatic on import.
+      cli.run(["autopilot", "update", id, "--status", "paused"]);
+      created++;
+    }
+    idMap.set(rec.title, id);
+
+    // Triggers are additive and idempotent by kind+label — a re-import never
+    // duplicates a trigger already present on the matched autopilot. Webhook
+    // triggers are always reissued fresh (new secret), never copied from the bundle.
+    const existingTriggers = match ? getAutopilot(cli, id).triggers : [];
+    const present = new Set(existingTriggers.map((t) => `${t.kind}:${t.label ?? ""}`));
+    for (const t of rec.triggers ?? []) {
+      if (present.has(`${t.kind}:${t.label ?? ""}`)) continue;
+      const flags = ["--kind", t.kind];
+      if (t.kind === "schedule") {
+        flags.push("--cron", t.cron_expression);
+        if (t.timezone) flags.push("--timezone", t.timezone);
+      }
+      if (t.label) flags.push("--label", t.label);
+      cli.run(["autopilot", "trigger-add", id, ...flags]);
+      if (t.kind === "webhook") webhookReissued.push(rec.title);
+    }
+  }
+  return { idMap, created, updated, projectUnresolved, subscribersUnresolved, priorityNotCaptured, webhookReissued };
+}
+
 export function collectSourceRuntimes(manifest) {
   return [...new Set((manifest.agents ?? []).map((a) => a.source_runtime_id).filter(Boolean))];
 }
@@ -380,15 +473,21 @@ export function importBundle({ cli, dir, runtimeMap, include, fs = nodeFs }) {
     projectRes = importProjects({ cli, manifest, dir, agentIdMap: agentRes.idMap, fs });
   }
 
+  let autopilotRes = { idMap: new Map(), created: 0, updated: 0, projectUnresolved: [], subscribersUnresolved: [], priorityNotCaptured: [], webhookReissued: [] };
+  if (inc.has("autopilots")) {
+    autopilotRes = importAutopilots({ cli, manifest, dir, agentIdMap: agentRes.idMap, fs });
+  }
+
   return {
     include: [...inc],
-    created: { skills: skillRes.created, agents: agentRes.created, squads: squadsCreated, projects: projectRes.created },
-    updated: { skills: skillRes.updated, agents: agentRes.updated, squads: squadsUpdated, projects: projectRes.updated },
+    created: { skills: skillRes.created, agents: agentRes.created, squads: squadsCreated, projects: projectRes.created, autopilots: autopilotRes.created },
+    updated: { skills: skillRes.updated, agents: agentRes.updated, squads: squadsUpdated, projects: projectRes.updated, autopilots: autopilotRes.updated },
     mentionsRewritten: mentionRes.updated,
     skillIdMap: Object.fromEntries(skillRes.idMap),
     agentIdMap: Object.fromEntries(agentRes.idMap),
     squadIdMap: Object.fromEntries(squadIdMap),
     projectIdMap: Object.fromEntries(projectRes.idMap),
+    autopilotIdMap: Object.fromEntries(autopilotRes.idMap),
     secretsReminder: (manifest.agents ?? []).filter((a) => a.had_secrets).map((a) => a.name),
     secretsApplyFailures: agentRes.secretsApplyFailures,
     avatarApplyFailures: agentRes.avatarApplyFailures,
@@ -399,6 +498,10 @@ export function importBundle({ cli, dir, runtimeMap, include, fs = nodeFs }) {
     priorityUnsupported: projectRes.priorityUnsupported,
     resourcesUnsupported: projectRes.resourcesUnsupported,
     leadUnresolved: projectRes.leadUnresolved,
+    autopilotProjectUnresolved: autopilotRes.projectUnresolved,
+    autopilotSubscribersUnresolved: autopilotRes.subscribersUnresolved,
+    autopilotPriorityNotCaptured: autopilotRes.priorityNotCaptured,
+    autopilotWebhookReissued: autopilotRes.webhookReissued,
   };
 }
 
@@ -406,12 +509,13 @@ export function preflight({ cli, dir, runtimeMap, include, fs = nodeFs }) {
   const inc = include ?? new Set(["skills", "agents", "squads"]);
   const manifest = JSON.parse(fs.readFileSync(`${dir}/manifest.json`, "utf8"));
   const count = (k) => (manifest[k] ?? []).length;
-  const bundle = { skills: count("skills"), agents: count("agents"), squads: count("squads"), projects: count("projects") };
+  const bundle = { skills: count("skills"), agents: count("agents"), squads: count("squads"), projects: count("projects"), autopilots: count("autopilots") };
   const willImport = {
     skills: inc.has("skills") ? bundle.skills : 0,
     agents: inc.has("agents") ? bundle.agents : 0,
     squads: inc.has("squads") ? bundle.squads : 0,
     projects: inc.has("projects") ? bundle.projects : 0,
+    autopilots: inc.has("autopilots") ? bundle.autopilots : 0,
   };
 
   const incompatibilities = [];
@@ -448,6 +552,33 @@ export function preflight({ cli, dir, runtimeMap, include, fs = nodeFs }) {
     }
   }
 
+  if (inc.has("autopilots")) {
+    const bundleAgentNames = new Set((manifest.agents ?? []).map((a) => a.name));
+    let destAgentNames = null;
+    const agentAvailable = (name) => (inc.has("agents") && bundleAgentNames.has(name))
+      || (destAgentNames ??= new Set(listAgents(cli).map((a) => a.name))).has(name);
+    let destProjectTitles = null;
+    const projectAvailable = (title) => (destProjectTitles ??= new Set(listProjects(cli).map((p) => p.title))).has(title);
+
+    for (const entry of manifest.autopilots ?? []) {
+      const rec = JSON.parse(fs.readFileSync(`${dir}/${entry.file}`, "utf8"));
+      if (rec.assignee_type === "squad") {
+        incompatibilities.push({ type: "autopilot-squad-assignee-unsupported", detail: `${rec.title} → squad "${rec.assignee_name}" (the multica CLI has no command to assign a squad to an autopilot)` });
+      } else if (!agentAvailable(rec.assignee_name)) {
+        incompatibilities.push({ type: "autopilot-assignee-missing", detail: `${rec.title} → agent "${rec.assignee_name}" (ensure this agent exists in the destination or is included in this import)` });
+      }
+      if (!rec.priority) {
+        incompatibilities.push({ type: "autopilot-priority-not-captured", detail: `${rec.title} (the multica CLI/API never returns an autopilot's priority, so export could not capture it)` });
+      }
+      if (rec.project_title && !projectAvailable(rec.project_title)) {
+        incompatibilities.push({ type: "autopilot-project-missing", detail: `${rec.title} → project "${rec.project_title}" (not found in the destination)` });
+      }
+      if (rec.had_webhook_trigger) {
+        incompatibilities.push({ type: "autopilot-webhook-reissued", detail: `${rec.title} (webhook trigger will get a newly issued URL — the old one never travels)` });
+      }
+    }
+  }
+
   const secretsReminder = (manifest.agents ?? []).filter((a) => a.had_secrets).map((a) => a.name);
   return { bundle, willImport, runtimes, incompatibilities, secretsReminder };
 }

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

@@ -1,7 +1,7 @@
 import * as nodeFs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { makeCli, resolveWorkspaceId, findByName, findByTitle, listSkills, listAgents, listSquads, listProjects, realExec, requireAuth } from "./lib.mjs";
+import { makeCli, resolveWorkspaceId, findByName, findByTitle, listSkills, listAgents, listSquads, listProjects, listAutopilots, realExec, requireAuth } from "./lib.mjs";
 import { exportResource } from "./multica-export.mjs";
 import { importBundle } from "./multica-import.mjs";
 
@@ -11,8 +11,13 @@ export function resolveScopeId(cli, type, name) {
     if (!match) throw new Error(`Unknown project "${name}" in source workspace`);
     return { scope: "project", ids: { projectId: match.id } };
   }
+  if (type === "autopilot") {
+    const match = findByTitle(listAutopilots(cli), name);
+    if (!match) throw new Error(`Unknown autopilot "${name}" in source workspace`);
+    return { scope: "autopilot", ids: { autopilotId: match.id } };
+  }
   const lists = { skill: listSkills, agent: listAgents, squad: listSquads };
-  if (!lists[type]) throw new Error(`Unknown type "${type}" (skill|agent|squad|project)`);
+  if (!lists[type]) throw new Error(`Unknown type "${type}" (skill|agent|squad|project|autopilot)`);
   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];
@@ -28,7 +33,7 @@ export function sync({ exec, type, name, srcWsName, destWsName, tmpDir, runtimeM
 
   const { scope, ids } = resolveScopeId(srcCli, type, name);
   exportResource({ cli: srcCli, scope, ids, outDir: tmpDir, sourceWorkspaceId: srcId, fs });
-  const includeByType = { skill: ["skills"], agent: ["agents"], squad: ["agents", "squads"], project: ["agents", "projects"] };
+  const includeByType = { skill: ["skills"], agent: ["agents"], squad: ["agents", "squads"], project: ["agents", "projects"], autopilot: ["agents", "squads", "autopilots"] };
   const include = new Set(includeByType[type] ?? ["agents", "squads"]);
   if (include.has("agents")) include.add("skills");
   return importBundle({ cli: destCli, dir: tmpDir, runtimeMap, include, fs });

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

@@ -6,7 +6,7 @@ allowed-tools: Bash, Read
 
 # export
 
-Export a Multica resource (skill, agent, or squad) to a local bundle directory.
+Export a Multica resource (skill, agent, squad, project, or autopilot) to a local bundle directory.
 
 ## Step 1 — Verify authentication
 
@@ -20,7 +20,7 @@ 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`, `squad`, or `project`), use those directly.
+If the user named a specific resource and type (`skill`, `agent`, `squad`, `project`, or `autopilot`), use those directly.
 
 Otherwise, list available resources for the chosen type and present a pick list:
 
@@ -32,25 +32,39 @@ 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:
+If the user specified an output directory, use it verbatim. Otherwise default to a workspace-rooted path.
 
+First resolve `<workspace-name>`:
+
+- If the user named a source workspace (the value you would pass as `--workspace <name>`), use that name.
+- Otherwise, read the current default workspace's name:
+
+```bash
+multica workspace get --output json
 ```
-./multica-export-<slug>-<type>
-```
 
-where `<slug>` is a lowercased, hyphenated form of the resource name.
+  and take its `.name`.
+
+Slugify the resolved name for filesystem safety — lowercase it, replace each run of non-`[a-z0-9]` characters with a single `-`, and trim leading/trailing `-` (the same rule the scripts use internally).
+
+Then construct the default directory by scope:
+
+- `all` or `projects` (whole workspace) → `export/<workspace-name>`
+- a single resource (`skill`, `agent`, `squad`, `project`, or `autopilot`) → `export/<workspace-name>/<slug>-<type>`, where `<slug>` is the slugified resource name and `<type>` is the resource type.
+
+Examples: `export all from mx-workspace` → `export/mx-workspace`; `export skill "Foo Bar" from mx-workspace` → `export/mx-workspace/foo-bar-skill`.
 
 ## Step 4 — Run the export
 
 ```bash
 node "${CLAUDE_PLUGIN_ROOT}/scripts/multica-export.mjs" \
-  --scope <skill|agent|squad|project|projects|all> \
+  --scope <skill|agent|squad|project|projects|autopilot|all> \
   --id <id> \
   --out <dir> \
   [--workspace <workspace-name>]
 ```
 
-`--id` is required for `skill`, `agent`, `squad`, and `project` (a single named resource); it is **not needed** for `projects` (every project in the workspace) or `all` (the entire workspace).
+`--id` is required for `skill`, `agent`, `squad`, `project`, and `autopilot` (a single named resource); it is **not needed** for `projects` (every project in the workspace) or `all` (the entire workspace). `all` does **not** include autopilots — an autopilot is always exported explicitly, by name, never auto-bundled.
 
 Pass `--scope all` (with no `--id`) to export the **entire workspace** — every skill, agent, squad, and project — into one flat, deduped bundle. A skill or agent shared across many agents/squads is written exactly once and referenced by name.
 
@@ -60,6 +74,8 @@ The script writes `manifest.json`, skill `SKILL.md` files, agent JSON files, and
 
 Avatars are captured automatically: an agent's uploaded-image avatar is downloaded into the bundle (`agents/<slug>.avatar.<ext>`) and referenced by `avatar_file`; emoji avatars (agents and squads) and a squad's avatar are recorded as the `avatar_url` string.
 
+Exporting `--scope autopilot` bundles the autopilot's **assignee** so the bundle is self-contained — an agent assignee (and its skills), or a squad assignee (its members, their skills, and the squad itself). It also captures the schedule and webhook triggers, the target project's **title** (not its ID — resolved by name on import) when one is set, and human subscribers' **names** (not their IDs). A webhook trigger's secret (URL/token) is **never** written to the bundle — only that it exists (its label); a fresh secret is issued on import.
+
 ## Step 5 — Report results
 
 Parse the JSON output from the script and report:
@@ -68,3 +84,4 @@ Parse the JSON output from the script and report:
 - Count of skills, agents, squads, and projects exported.
 - If `pruned_skills` is non-empty, note it: "Pruned N orphan skill(s) not linked to any agent: `<name>`, …" (these are standalone workspace skills that no exported agent references — only `--scope all` produces them).
 - If `warnings` is non-empty, surface every agent name verbatim with this message: "WARNING: the following agents' exported files contain custom environment variables or MCP config in PLAINTEXT — treat the export directory as sensitive (avoid committing it to a public repo, restrict file permissions, delete it once the import is done): `<agent-name>`."
+- If `autopilotWebhookTriggers` is non-empty, surface every autopilot title verbatim with: "NOTE: the following autopilots have a webhook trigger — its secret was NOT exported; a newly issued URL will be created on import: `<autopilot-title>`."

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

@@ -8,19 +8,24 @@ allowed-tools: Bash, Read
 
 Import a local Multica bundle (produced by the export skill) into a target workspace.
 
-## Step 1 — Confirm the target workspace
+## Step 1 — Determine 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.
+You need the exact workspace name as registered in Multica for `--workspace` in the steps below.
+
+- If the user named a target workspace, use it.
+- If the user did **not** name one, default to the **basename of the import folder** — e.g. importing from `export/mx-workspace` defaults the target workspace to `mx-workspace`. State the inferred workspace name to the user before continuing.
+
+No existence check is needed here: the Step 2 dry-run fails with `Unknown workspace "<name>"` if the inferred workspace is not present in the target account, at which point ask the user for the correct name.
 
 ## Step 2 — Pre-flight (dry run)
 
-Before writing anything, run the import script with `--dry-run` to preview the bundle. Preview against the **full** set (`--include agents,squads,projects`) regardless of what the user ultimately chooses to import — incompatibilities for a type (e.g. project caveats) are only computed when that type is included, so previewing everything up front is what lets the user see a project's cost before deciding whether to opt it in:
+Before writing anything, run the import script with `--dry-run` to preview the bundle. Preview against the **full** set (`--include agents,squads,projects,autopilots`) regardless of what the user ultimately chooses to import — incompatibilities for a type (e.g. project caveats) are only computed when that type is included, so previewing everything up front is what lets the user see a project's or autopilot's cost before deciding whether to opt it in:
 
 ```bash
 node "${CLAUDE_PLUGIN_ROOT}/scripts/multica-import.mjs" \
   --dir <folder> \
   --workspace <workspace-name> \
-  --include agents,squads,projects \
+  --include agents,squads,projects,autopilots \
   [--runtime-map <srcId1=dstId1,srcId2=dstId2,...>] \
   --dry-run
 ```
@@ -29,9 +34,9 @@ Present the `bundle` and `willImport` counts, and every entry in `incompatibilit
 
 ## Step 3 — Select which types to import
 
-Ask the user which of `agents`, `squads`, `projects` they want to import. **Default is `agents,squads`** — `projects` requires explicit opt-in.
+Ask the user which of `agents`, `squads`, `projects`, `autopilots` they want to import. **Default is `agents,squads`** — `projects` and `autopilots` each require explicit opt-in.
 
-If the pre-flight's `incompatibilities` list contains an `unmapped-runtime` entry, tell the user it must be resolved with `--runtime-map` before the real import — the import **aborts** otherwise (see Step 4 below). Other incompatibility kinds are informational only and applied best-effort, fixed up afterward in the Multica UI: `priority-not-settable` (priority isn't settable via the CLI, so it never round-trips), `resource-not-portable` (only `github_repo` resources are portable — other resource kinds are dropped), and `lead-agent-missing` (a non-agent lead isn't re-applied to the imported project).
+If the pre-flight's `incompatibilities` list contains an `unmapped-runtime` or `autopilot-squad-assignee-unsupported` entry, tell the user it **aborts the import before any write** (see Step 4 below) — `unmapped-runtime` needs `--runtime-map`; a squad-assigned autopilot has no fix, since the multica CLI has no command to assign a squad to an autopilot (only `--agent`) — drop that autopilot from the bundle or recreate its assignment by hand after importing the squad. An `autopilot-assignee-missing` entry also aborts unless resolved by including `agents` or ensuring that agent already exists in the destination. Other incompatibility kinds are informational only and applied best-effort, fixed up afterward in the Multica UI: `priority-not-settable` (project priority isn't settable via the CLI, so it never round-trips), `resource-not-portable` (only `github_repo` resources are portable — other resource kinds are dropped), `lead-agent-missing` (a non-agent lead isn't re-applied to the imported project), `autopilot-priority-not-captured` (the multica CLI/API never returns an autopilot's priority, so it can't be captured or restored at all — a known platform gap, not a bug in this tool), `autopilot-project-missing` (the autopilot's target project isn't found by title in the destination — it's created/updated with no project set), and `autopilot-webhook-reissued` (informational — the webhook trigger always gets a freshly issued URL).
 
 ## Step 4 — Run the import (auto-mapping first)
 
@@ -41,7 +46,7 @@ Each exported agent record carries its source runtime's `provider` (e.g. `claude
 node "${CLAUDE_PLUGIN_ROOT}/scripts/multica-import.mjs" \
   --dir <folder> \
   --workspace <workspace-name> \
-  --include <agents,squads,projects>
+  --include <agents,squads,projects,autopilots>
 ```
 
 If it aborts with `Unmapped runtimes: ...` (0 or 2+ runtimes share that provider in the target workspace, or the bundle predates provider capture), resolve manually:
@@ -57,23 +62,28 @@ Ask the user to pick a matching target runtime by name or ID for each unmapped `
 node "${CLAUDE_PLUGIN_ROOT}/scripts/multica-import.mjs" \
   --dir <folder> \
   --workspace <workspace-name> \
-  --include <agents,squads,projects> \
+  --include <agents,squads,projects,autopilots> \
   --runtime-map <srcId1=dstId1,srcId2=dstId2,...>
 ```
 
+If it instead aborts with `Unresolved autopilot assignees: ...`, that is not fixable with `--runtime-map` — either the autopilot is squad-assigned (no CLI support, see Step 3) or its assignee agent isn't available in this import or the destination; ensure `agents` is included, or that the agent already exists in the destination workspace under the same name, then re-run.
+
 The import also rewrites any `mention://agent/<id>` link inside squad and agent instructions (e.g. `[@dev-backend](mention://agent/<id>)`) from the source agent's id to its new id in the target workspace — the CLI does this automatically for every agent captured in the bundle; no extra flag needed. Mentions pointing to an agent outside the bundle are left untouched.
 
 Instructions are read back from each resource's sibling `.md` (`agents/<slug>.md`, `squads/<slug>.md`) when present — editing that Markdown is the supported way to review and enhance an agent's or squad's instructions before import. Older bundles that predate the split (instructions inline in the JSON, no `instructions_file`) still import unchanged.
 
 Avatars are restored automatically, but **only when the target resource has none** — an existing agent or squad that already carries an avatar is never overwritten. New agents get their bundled image re-uploaded; new squads get their `avatar_url` (emoji or URL) set. An agent whose source avatar was an emoji can't be restored (the CLI has no emoji setter for agents) and is reported as unsupported.
 
+Importing `autopilots` always creates a brand-new autopilot **paused**, regardless of the source's status — activation is left as a deliberate follow-up action, never automatic. Re-importing an already-imported autopilot updates it by title (never duplicates) but leaves its current status alone. Its triggers are upserted by kind+label — a re-import never adds a duplicate trigger — and a webhook trigger always gets a freshly issued URL, never the source's.
+
 ## Step 5 — Report results
 
 Parse the JSON output and report:
 
-- Created and updated counts for skills, agents, squads, and projects (`created.projects`/`updated.projects`).
+- Created and updated counts for skills, agents, squads, projects, and autopilots (`created.autopilots`/`updated.autopilots`).
 - Name-to-ID maps for skills and agents (`skillIdMap`, `agentIdMap`).
 - `squadIdMap`: name-to-ID map for every squad imported.
+- `autopilotIdMap`: name-to-ID map for every autopilot imported.
 - `mentionsRewritten`: how many agents had an agent-mention link rewritten to its new id.
 - If `leadUnresolved`, `priorityUnsupported`, `resourcesUnsupported`, or `squadsSkipped` is non-empty, surface each entry verbatim as an "applied best-effort; adjust in the UI" note — e.g. "NOTE: applied best-effort; adjust in the UI — `<entry>`."
 - If `secretsReminder` is non-empty, surface every agent name verbatim with: "WARNING: the following agents' bundle files contained custom environment variables or MCP config in PLAINTEXT — the source export directory should be treated as sensitive: `<agent-name>`."
@@ -82,3 +92,7 @@ Parse the JSON output and report:
 - If `avatarUnsupported` is non-empty, surface every agent name verbatim with: "NOTE: the following agents had an emoji avatar at the source, which the CLI cannot set on an agent — set it manually in the Multica UI: `<agent-name>`."
 - If `permissionApplyFailures` is non-empty, surface every agent name verbatim with: "WARNING: member-specific sharing failed to apply for the following agents — set their invocation permissions manually in the Multica UI: `<agent-name>`."
 - If `permissionUnsupported` is non-empty, surface every agent name verbatim with: "NOTE: the following agents were shared with specific members at the source, but none of those users exist in the target workspace — re-share manually if needed: `<agent-name>`."
+- If `autopilotProjectUnresolved` is non-empty, surface every autopilot title verbatim with: "NOTE: the following autopilots' target project could not be matched by title in the target workspace — created/updated with no project set: `<autopilot-title>`."
+- If `autopilotSubscribersUnresolved` is non-empty, surface every `<title>:<member-name>` entry verbatim with: "NOTE: the following autopilot subscribers could not be matched by name in the target workspace — skipped: `<entry>`."
+- If `autopilotPriorityNotCaptured` is non-empty, surface every autopilot title verbatim with: "NOTE: the following autopilots' priority could not be captured from the source (the multica CLI/API never returns it) — a known platform gap, not something this tool can fix: `<autopilot-title>`."
+- If `autopilotWebhookReissued` is non-empty, surface every autopilot title verbatim with: "NOTE: the following autopilots had a webhook trigger created with a freshly issued URL — the previous URL does not carry over: `<autopilot-title>`."

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

@@ -16,9 +16,9 @@ Expect the user's request in the form:
 sync <type> <name> from <src-ws> to <dest-ws>
 ```
 
-Where `<type>` is `skill`, `agent`, `squad`, or `project`; `<name>` is the resource name (for `project`, its **title**); `<src-ws>` and `<dest-ws>` are workspace names registered in Multica.
+Where `<type>` is `skill`, `agent`, `squad`, `project`, or `autopilot`; `<name>` is the resource name (for `project` and `autopilot`, its **title**); `<src-ws>` and `<dest-ws>` are workspace names registered in Multica.
 
-Projects are resolved by title, not ID, e.g. `multica-sync.mjs project "<title>" from <src-ws> <dest-ws>` — the project's lead agent is synced alongside it.
+Projects and autopilots are resolved by title, not ID, e.g. `multica-sync.mjs project "<title>" from <src-ws> <dest-ws>` — the project's lead agent is synced alongside it. `multica-sync.mjs autopilot "<title>" from <src-ws> <dest-ws>` syncs the autopilot's assignee (agent, or squad + members) alongside it; a squad-assigned autopilot aborts (see the import skill — the multica CLI has no command to assign a squad to an autopilot).
 
 ## Step 2 — Run the sync (auto-mapping first)
 
@@ -49,9 +49,12 @@ The script exports to a temporary directory, imports into the destination worksp
 
 Parse the JSON output and report:
 
-- Created and updated counts for skills, agents, squads, and projects.
+- Created and updated counts for skills, agents, squads, projects, and autopilots.
 - Name-to-ID maps (`skillIdMap`, `agentIdMap`).
 - `squadIdMap`: name-to-ID map for every squad synced.
+- `autopilotIdMap`: name-to-ID map for every autopilot synced. Importing always creates a new autopilot **paused**, regardless of source status; a re-sync updates the existing one by title without reactivating or duplicating it, and never re-adds a trigger already present.
+- If `autopilotProjectUnresolved`, `autopilotSubscribersUnresolved`, or `autopilotPriorityNotCaptured` is non-empty, surface each entry verbatim as an "applied best-effort" note (project/subscribers skipped when unmatched by name in the destination; priority can never be captured — a platform gap, not a bug here).
+- If `autopilotWebhookReissued` is non-empty, surface every autopilot title verbatim with: "NOTE: the following autopilots had a webhook trigger created with a freshly issued URL in the destination — the previous URL does not carry over: `<autopilot-title>`."
 - If `secretsReminder` is non-empty, surface every agent name verbatim with: "WARNING: the following agents' bundle files contained custom environment variables or MCP config in PLAINTEXT — the temporary export directory (already cleaned up) briefly held these secrets in plaintext: `<agent-name>`."
 - If `secretsApplyFailures` is non-empty, surface every agent name verbatim with: "WARNING: mcp_config or custom_env failed to apply to the following agents during sync (the agent itself was still created/updated) — set them manually in the Multica UI: `<agent-name>`."
 - If `avatarApplyFailures` is non-empty, surface every agent name verbatim with: "WARNING: the avatar image failed to upload for the following agents — set it manually in the destination workspace: `<agent-name>`."

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

@@ -1,7 +1,7 @@
 {
   "name": "plugin-validator",
   "displayName": "Plugin Validator",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "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.41",
+  "version": "0.0.43",
   "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.41",
+  "version": "0.0.43",
   "description": "Step-by-step wizard for generating technical diagrams as SVG+PNG.",
   "author": {
     "name": "steven"