@drunkcoding/agents-and-skills 0.0.42 → 0.0.44

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.42",
+      "version": "0.0.44",
       "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.42",
+      "version": "0.0.44",
       "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.42",
+      "version": "0.0.44",
       "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.42",
+      "version": "0.0.44",
       "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.42",
+      "version": "0.0.44",
       "category": "workflow",
       "keywords": [
         "multica",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drunkcoding/agents-and-skills",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "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.42",
+  "version": "0.0.44",
   "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.42",
+  "version": "0.0.44",
   "description": "Export, import, and sync Multica skills, agents, and squads between workspaces via the multica CLI."
 }

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

@@ -53,6 +53,9 @@ export function resolveWorkspaceId(cli, name) {
 export const listRuntimes = (cli) => cli.json(["runtime", "list"]);
 export const listSkills = (cli) => cli.json(["skill", "list"]);
 export const listAgents = (cli) => cli.json(["agent", "list"]);
+// Includes archived agents (archived_at set) — used wherever a name match or an
+// id lookup must also see agents excluded from the default listing above.
+export const listAgentsIncludingArchived = (cli) => cli.json(["agent", "list", "--include-archived"]);
 export const listSquads = (cli) => cli.json(["squad", "list"]);
 export const listWorkspaceMembers = (cli) => cli.json(["workspace", "member", "list"]);
 
@@ -72,6 +75,8 @@ 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,
+    // Export-time signal only (never written to a bundle record — see redactAgent).
+    archived_at: a.archived_at ?? null,
     model: a.model, visibility: a.visibility, avatar_url: a.avatar_url ?? null,
     service_tier: a.service_tier ?? "",
     permission_mode: a.permission_mode ?? null,
@@ -127,3 +132,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, listAgentsIncludingArchived, 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;
 
@@ -31,7 +31,7 @@ export function redactAgent(a) {
   // a is a normalized agent from getAgent, with `custom_env`/
   // `custom_env_fetch_failed` attached by the caller (collectAgent) — getAgent
   // itself never fetches custom_env, since it requires a separate audited call.
-  const { id, has_custom_env, mcp_config_redacted, custom_env_fetch_failed, mcp_config, custom_env, skills, runtime_id, instructions, ...rest } = a;
+  const { id, has_custom_env, mcp_config_redacted, custom_env_fetch_failed, mcp_config, custom_env, skills, runtime_id, instructions, archived_at, ...rest } = a;
   const mcpUsable = !mcp_config_redacted && nonEmpty(mcp_config);
   const envUsable = !custom_env_fetch_failed && nonEmpty(custom_env);
   // mcp_config_redacted / custom_env_fetch_failed alone still flag hadSecrets even
@@ -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,
+    })),
   };
 }
 
@@ -91,10 +96,15 @@ function collectSkill(cli, id, skills) {
 }
 
 // Keyed by agent id (so squad leader_id/member_id resolve to names). Stores the
-// normalized agent, its redaction result, and its skill names.
+// normalized agent, its redaction result, and its skill names. Returns
+// `{ archived: true, name }` instead of collecting when the agent is archived —
+// callers reached via a squad/project/explicit id lookup must decide how to
+// handle that (the workspace-listing loop never hits this: listAgents() already
+// excludes archived agents server-side).
 function collectAgent(cli, id, agentsById, skills, providerById) {
   if (agentsById.has(id)) return agentsById.get(id);
   const a = getAgent(cli, id);
+  if (a.archived_at) return { archived: true, name: a.name };
   a.source_runtime_provider = providerById.get(a.runtime_id) ?? null;
   a.custom_env = {};
   a.custom_env_fetch_failed = false;
@@ -112,38 +122,45 @@ function collectAgent(cli, id, agentsById, skills, providerById) {
   return entry;
 }
 
-// Collect a project's portable metadata + its lead agent (bundled, like a squad
-// leader) and github_repo/other resources. Returns the project bundle record.
-function collectProject(cli, id, agentsById, skills, providerById) {
-  const p = getProject(cli, id);
-  let lead_name = null;
-  if (p.lead_type === "agent" && p.lead_id) {
-    lead_name = collectAgent(cli, p.lead_id, agentsById, skills, providerById).raw.name;
-  }
-  return {
-    title: p.title, description: p.description, icon: p.icon,
-    priority: p.priority, status: p.status, due_date: p.due_date, start_date: p.start_date,
-    source_id: id, lead_type: p.lead_type, lead_name, lead_source_id: p.lead_id,
-    resources: getProjectResources(cli, id),
-  };
-}
-
 export function exportResource({ cli, scope, ids, outDir, sourceWorkspaceId, fs = nodeFs, download = fetchBinary }) {
   const skills = new Map();       // name -> normalized skill
   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;
   const getProviderById = () => providerById ??= new Map(listRuntimes(cli).map((r) => [r.id, r.provider]));
 
-  // Collect a squad's agents (leader + members) and return the squad bundle object.
+  // Archived agents skipped anywhere below, deduped by (name, path, detail) —
+  // the operator-facing "why isn't X in my bundle" report.
+  const archivedAgentsSkipped = [];
+  const seenArchivedSkip = new Set();
+  function recordArchivedSkip(name, path, detail) {
+    const key = [name, path, detail ?? ""].join("|");
+    if (seenArchivedSkip.has(key)) return;
+    seenArchivedSkip.add(key);
+    archivedAgentsSkipped.push(detail ? { name, path, detail } : { name, path });
+  }
+
+  // Collect a squad's agents (leader + members) and return the squad bundle
+  // object — or null when the leader is archived, since a squad can't import
+  // without one (the whole squad is excluded from the bundle, not emitted leaderless).
   function collectOneSquad(squadId) {
     const sq = getSquad(cli, squadId);
-    const members = getSquadMembers(cli, squadId).filter((m) => m.member_type === "agent");
-    for (const m of members) collectAgent(cli, m.member_id, agentsById, skills, getProviderById());
-    if (!agentsById.has(sq.leader_id)) collectAgent(cli, sq.leader_id, agentsById, skills, getProviderById());
+    const leaderEntry = collectAgent(cli, sq.leader_id, agentsById, skills, getProviderById());
+    if (leaderEntry.archived) {
+      recordArchivedSkip(leaderEntry.name, "squad leader", sq.name);
+      return null;
+    }
+    const allMembers = getSquadMembers(cli, squadId).filter((m) => m.member_type === "agent");
+    const members = [];
+    for (const m of allMembers) {
+      const entry = collectAgent(cli, m.member_id, agentsById, skills, getProviderById());
+      if (entry.archived) { recordArchivedSkip(entry.name, "squad member", sq.name); continue; }
+      members.push(m);
+    }
     const nameOf = (id) => agentsById.get(id)?.raw.name;
     return {
       name: sq.name, description: sq.description, instructions: sq.instructions, avatar_url: sq.avatar_url,
@@ -152,16 +169,83 @@ export function exportResource({ cli, scope, ids, outDir, sourceWorkspaceId, fs
     };
   }
 
+  // Collect a project's portable metadata + its lead agent (bundled, like a
+  // squad leader) and github_repo/other resources. An archived lead is dropped
+  // (project still exports, just with no lead set) — unlike a squad, a project
+  // has no hard requirement for one.
+  function collectProject(id) {
+    const p = getProject(cli, id);
+    let lead_name = null, lead_type = p.lead_type, lead_source_id = p.lead_id;
+    if (p.lead_type === "agent" && p.lead_id) {
+      const entry = collectAgent(cli, p.lead_id, agentsById, skills, getProviderById());
+      if (entry.archived) {
+        recordArchivedSkip(entry.name, "project lead", p.title);
+        lead_type = null; lead_source_id = null;
+      } else {
+        lead_name = entry.raw.name;
+      }
+    }
+    return {
+      title: p.title, description: p.description, icon: p.icon,
+      priority: p.priority, status: p.status, due_date: p.due_date, start_date: p.start_date,
+      source_id: id, lead_type, lead_name, lead_source_id,
+      resources: getProjectResources(cli, id),
+    };
+  }
+
+  // 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") {
+      const entry = collectAgent(cli, ap.assignee_id, agentsById, skills, getProviderById());
+      assignee_name = entry.archived ? null : entry.raw.name;
+    } else if (ap.assignee_type === "squad") {
+      const sq = collectOneSquad(ap.assignee_id);
+      if (sq) { 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 === "agent") {
+    const entry = collectAgent(cli, ids.agentId, agentsById, skills, getProviderById());
+    if (entry.archived) throw new Error(`Cannot export agent "${entry.name}": it is archived`);
+  }
+  else if (scope === "squad") { const sq = collectOneSquad(ids.squadId); if (sq) squads.push(sq); }
+  else if (scope === "project") projects.push(collectProject(ids.projectId));
+  else if (scope === "projects") for (const p of listProjects(cli)) projects.push(collectProject(p.id));
+  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());
-    for (const sq of listSquads(cli)) squads.push(collectOneSquad(sq.id));
-    for (const p of listProjects(cli)) projects.push(collectProject(cli, p.id, agentsById, skills, getProviderById()));
+    for (const sq of listSquads(cli)) { const built = collectOneSquad(sq.id); if (built) squads.push(built); }
+    for (const p of listProjects(cli)) projects.push(collectProject(p.id));
+    // listAgents() above already excludes archived agents server-side — surface
+    // that exclusion in the report too, not just the squad/project paths.
+    for (const a of listAgentsIncludingArchived(cli)) {
+      if (a.archived_at) recordArchivedSkip(a.name, "workspace listing");
+    }
   }
 
   // Orphan-skill cleanup: drop skills that no exported agent references via its
@@ -183,6 +267,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 +326,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, archivedAgentsSkipped,
+    autopilotWebhookTriggers: autopilots.filter((a) => a.had_webhook_trigger).map((a) => a.title),
+  };
 }
 
 function main() {
@@ -255,7 +348,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 +365,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, listAgentsIncludingArchived, 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");
@@ -86,8 +86,10 @@ export function importAgents({ cli, manifest, dir, skillIdMap, runtimeMap, fs =
   // Lazy + memoized: destination member user_ids, only listed when an agent needs them.
   let destMemberIds = null;
   const getDestMemberIds = () => destMemberIds ??= new Set(listWorkspaceMembers(cli).map((m) => m.user_id));
-  let created = 0, updated = 0;
-  const existing = listAgents(cli);
+  let created = 0, updated = 0, reused = 0;
+  // Includes archived agents so a bundle name matching a retired agent restores
+  // and reuses it instead of failing to create under the held name.
+  const existing = listAgentsIncludingArchived(cli);
 
   for (const a of manifest.agents) {
     const rec = JSON.parse(fs.readFileSync(`${dir}/${a.file}`, "utf8"));
@@ -108,7 +110,14 @@ export function importAgents({ cli, manifest, dir, skillIdMap, runtimeMap, fs =
     if (rec.service_tier) common.push("--service-tier", rec.service_tier);
     const match = findByName(existing, rec.name);
     let id;
-    if (match) {
+    if (match && match.archived_at) {
+      // Restored agent then updated exactly like an active-name match — the
+      // matched id is now active, so a re-import of this bundle will find it
+      // via the plain `match` branch below and never restore twice.
+      cli.run(["agent", "restore", match.id]);
+      cli.run(["agent", "update", match.id, "--runtime-id", targetRuntime, ...common]);
+      id = match.id; reused++;
+    } else if (match) {
       cli.run(["agent", "update", match.id, "--runtime-id", targetRuntime, ...common]);
       id = match.id; updated++;
     } else {
@@ -178,7 +187,7 @@ export function importAgents({ cli, manifest, dir, skillIdMap, runtimeMap, fs =
       }
     }
   }
-  return { idMap, sourceIdMap, created, updated, secretsApplyFailures, avatarApplyFailures, avatarUnsupported, permissionApplyFailures, permissionUnsupported };
+  return { idMap, sourceIdMap, created, updated, reused, secretsApplyFailures, avatarApplyFailures, avatarUnsupported, permissionApplyFailures, permissionUnsupported };
 }
 
 // Rewrites `mention://agent/<id>` links (e.g. `[@dev-backend](mention://agent/<id>)`)
@@ -298,6 +307,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))];
 }
@@ -355,7 +457,7 @@ export function importBundle({ cli, dir, runtimeMap, include, fs = nodeFs }) {
     : { idMap: new Map(), created: 0, updated: 0 };
   const agentRes = inc.has("agents")
     ? importAgents({ cli, manifest, dir, skillIdMap: skillRes.idMap, runtimeMap: effective, fs })
-    : { idMap: new Map(), sourceIdMap: new Map(), created: 0, updated: 0, secretsApplyFailures: [], avatarApplyFailures: [], avatarUnsupported: [], permissionApplyFailures: [], permissionUnsupported: [] };
+    : { idMap: new Map(), sourceIdMap: new Map(), created: 0, updated: 0, reused: 0, secretsApplyFailures: [], avatarApplyFailures: [], avatarUnsupported: [], permissionApplyFailures: [], permissionUnsupported: [] };
   // Runs after every agent exists so forward-referencing mentions resolve.
   const mentionRes = inc.has("agents")
     ? rewriteAgentMentions({ cli, manifest, dir, agentIdMap: agentRes.idMap, sourceIdMap: agentRes.sourceIdMap, fs })
@@ -380,15 +482,24 @@ 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 },
+    // Agents restored from archived + updated to the bundle's definition — distinct
+    // from a plain update (an active-name match). Only agents can be reused today.
+    reused: { agents: agentRes.reused },
     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 +510,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 +521,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 = [];
@@ -427,6 +543,16 @@ export function preflight({ cli, dir, runtimeMap, include, fs = nodeFs }) {
         ? `${u.srcId} (provider "${u.provider}": ${u.matchCount} matches, expected 1)`
         : `${u.srcId} (no provider recorded)` });
     }
+
+    // Read-only check, mirrors importAgents' restore-and-reuse match — never
+    // calls restore itself, just reports what a real import would do.
+    const existingAgents = listAgentsIncludingArchived(cli);
+    for (const a of manifest.agents ?? []) {
+      const match = findByName(existingAgents, a.name);
+      if (match && match.archived_at) {
+        incompatibilities.push({ type: "agent-archived-will-restore", detail: `${a.name} (archived in destination — import would restore and reuse it)` });
+      }
+    }
   }
 
   if (inc.has("projects")) {
@@ -448,6 +574,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:
 
@@ -50,7 +50,7 @@ Slugify the resolved name for filesystem safety — lowercase it, replace each r
 Then construct the default directory by scope:
 
 - `all` or `projects` (whole workspace) → `export/<workspace-name>`
-- a single resource (`skill`, `agent`, `squad`, or `project`) → `export/<workspace-name>/<slug>-<type>`, where `<slug>` is the slugified resource name and `<type>` is the resource type.
+- 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`.
 
@@ -58,13 +58,13 @@ Examples: `export all from mx-workspace` → `export/mx-workspace`; `export skil
 
 ```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.
 
@@ -74,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:
@@ -82,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

@@ -19,13 +19,13 @@ No existence check is needed here: the Step 2 dry-run fails with `Unknown worksp
 
 ## 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
 ```
@@ -34,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)
 
@@ -46,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:
@@ -62,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>`."
@@ -87,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.42",
+  "version": "0.0.44",
   "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.42",
+  "version": "0.0.44",
   "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.42",
+  "version": "0.0.44",
   "description": "Step-by-step wizard for generating technical diagrams as SVG+PNG.",
   "author": {
     "name": "steven"