bambu-printer-mcp 1.0.8 → 1.1.2

package/src/index.ts

@@ -24,38 +24,477 @@ import {
   type SlicerType,
 } from "./stl/stl-manipulator.js";
 import { BambuNetworkBridge, type BambuNetworkBridgeOptions } from "./bambu-network-bridge.js";
-import { parse3MF } from './3mf_parser.js';
+import { hasAmsMappingInput, normalizeAmsMappingObject, normalizeBridgeAmsTrayValue } from "./ams-mapping.js";
+import { analyze3MFAmsRequirements, analyze3MFPlateObjects, analyzeCollarCharm3MF, extractBambuTemplateSettings, getCollarCharmRolePolicy, parse3MF } from './3mf_parser.js';
+import type { ThreeMFAmsRequirements } from "./types.js";
 import { BambuImplementation } from "./printers/bambu.js";
 
 dotenv.config();
 
-const DEFAULT_HOST = process.env.PRINTER_HOST || "localhost";
-const DEFAULT_BAMBU_SERIAL = process.env.BAMBU_SERIAL || "";
-const DEFAULT_BAMBU_TOKEN = process.env.BAMBU_TOKEN || "";
+const DEFAULT_HOST = process.env.BAMBU_PRINTER_HOST || process.env.PRINTER_HOST || "localhost";
+const DEFAULT_BAMBU_SERIAL = process.env.BAMBU_PRINTER_SERIAL || process.env.BAMBU_SERIAL || "";
+const DEFAULT_BAMBU_TOKEN =
+  process.env.BAMBU_PRINTER_ACCESS_TOKEN || process.env.BAMBU_TOKEN || "";
 const DEFAULT_BAMBU_DEV_ID = process.env.BAMBU_DEV_ID || DEFAULT_BAMBU_SERIAL;
 const TEMP_DIR = process.env.TEMP_DIR || path.join(process.cwd(), "temp");
 
 // Printer model and bed type
-const DEFAULT_BAMBU_MODEL = process.env.BAMBU_MODEL?.trim().toLowerCase() || "";
+const DEFAULT_BAMBU_MODEL =
+  process.env.BAMBU_PRINTER_MODEL?.trim().toLowerCase() ||
+  process.env.BAMBU_MODEL?.trim().toLowerCase() ||
+  "";
 const DEFAULT_BED_TYPE = process.env.BED_TYPE?.trim().toLowerCase() || "textured_plate";
 const DEFAULT_NOZZLE_DIAMETER = process.env.NOZZLE_DIAMETER?.trim() || "0.4";
 
-const VALID_BAMBU_MODELS = ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"] as const;
+const VALID_BAMBU_MODELS = ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"] as const;
 type BambuModel = typeof VALID_BAMBU_MODELS[number];
 
-const VALID_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"] as const;
+const VALID_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"] as const;
+const VALID_BAMBUSTUDIO_CLI_BED_TYPES = ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"] as const;
 
 // Map model IDs to BambuStudio --load-machine preset names
 const BAMBU_MODEL_PRESETS: Record<string, (nozzle: string) => string> = {
   p1s: (n) => `Bambu Lab P1S ${n} nozzle`,
   p1p: (n) => `Bambu Lab P1P ${n} nozzle`,
+  p2s: (n) => `Bambu Lab P2S ${n} nozzle`,
   x1c: (n) => `Bambu Lab X1 Carbon ${n} nozzle`,
   x1e: (n) => `Bambu Lab X1E ${n} nozzle`,
   a1: (n) => `Bambu Lab A1 ${n} nozzle`,
   a1mini: (n) => `Bambu Lab A1 mini ${n} nozzle`,
   h2d: (n) => `Bambu Lab H2D ${n} nozzle`,
+  h2s: (n) => `Bambu Lab H2S ${n} nozzle`,
 };
 
+const FILAMENT_PROFILE_DIR =
+  "/Applications/BambuStudio.app/Contents/Resources/profiles/BBL/filament";
+const FILAMENT_MODEL_CODES: Record<string, string> = {
+  p1s: "P1S",
+  p1p: "P1P",
+  p2s: "P2S",
+  x1c: "X1C",
+  x1e: "X1E",
+  a1: "A1",
+  a1mini: "A1M",
+  h2d: "H2D",
+  h2s: "H2S",
+};
+
+type FilamentProfileIndex = {
+  byName: Map<string, string>;
+  baseNameByFilamentId: Map<string, string>;
+};
+
+type PrinterFilamentInventory = {
+  current_slot: number | null;
+  current_source: "ams" | "external" | null;
+  summary: {
+    loaded_slots: number;
+    resolved_profile_slots: number;
+    unresolved_loaded_slots: number;
+    empty_slots: number;
+    current_slot: number | null;
+    current_source: "ams" | "external" | null;
+    recommended_slot: number | null;
+    recommended_reason: string | null;
+  };
+  trays: Array<{
+    ams_id: number | null;
+    tray_id: number | null;
+    slot: number | null;
+    state: number;
+    loaded: boolean;
+    tray_info_idx: string | null;
+    tray_type: string | null;
+    tray_sub_brands: string | null;
+    tray_color: string | null;
+    remain_percent: number | null;
+    nozzle_temp_min: number | null;
+    nozzle_temp_max: number | null;
+    resolved_base_profile_name: string | null;
+    resolved_profile_path: string | null;
+    profile_resolution: "exact-model-nozzle" | "model" | "generic" | "unresolved";
+    match_confidence: "high" | "medium" | "low" | "none";
+    display_name: string;
+    profile_candidates: string[];
+  }>;
+  recommended: {
+    slot: number | null;
+    tray_info_idx: string | null;
+    tray_type: string | null;
+    resolved_profile_path: string | null;
+    load_filaments: string | null;
+    reason: string;
+  } | null;
+  load_filaments_all: string | null;
+};
+
+const COLLAR_CHARM_POLICY = getCollarCharmRolePolicy();
+
+let filamentProfileIndexCache: FilamentProfileIndex | null = null;
+
+function buildFilamentProfileIndex(): FilamentProfileIndex {
+  const byName = new Map<string, string>();
+  const baseNameByFilamentId = new Map<string, string>();
+
+  if (!fs.existsSync(FILAMENT_PROFILE_DIR)) {
+    return { byName, baseNameByFilamentId };
+  }
+
+  for (const entry of fs.readdirSync(FILAMENT_PROFILE_DIR)) {
+    if (!entry.endsWith(".json")) continue;
+
+    const filePath = path.join(FILAMENT_PROFILE_DIR, entry);
+
+    try {
+      const raw = fs.readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const name = typeof parsed?.name === "string" ? parsed.name.trim() : "";
+      const filamentId = typeof parsed?.filament_id === "string" ? parsed.filament_id.trim() : "";
+
+      if (name) {
+        byName.set(name, filePath);
+      }
+      if (name && filamentId) {
+        baseNameByFilamentId.set(filamentId, name);
+      }
+    } catch {
+      // Ignore malformed or non-profile JSON files.
+    }
+  }
+
+  return { byName, baseNameByFilamentId };
+}
+
+function getFilamentProfileIndex(): FilamentProfileIndex {
+  if (!filamentProfileIndexCache) {
+    filamentProfileIndexCache = buildFilamentProfileIndex();
+  }
+
+  return filamentProfileIndexCache;
+}
+
+function resolveFilamentProfileCandidates(
+  trayInfoIdx: string,
+  bambuModel?: string,
+  nozzleDiameter?: string
+): {
+  baseName: string | null;
+  paths: string[];
+  resolution: "exact-model-nozzle" | "model" | "generic" | "unresolved";
+} {
+  const index = getFilamentProfileIndex();
+  const baseName = index.baseNameByFilamentId.get(trayInfoIdx) || null;
+  if (!baseName) {
+    return { baseName: null, paths: [], resolution: "unresolved" };
+  }
+
+  const bareName = baseName.replace(/\s*@base$/, "");
+  const modelCode = bambuModel ? FILAMENT_MODEL_CODES[bambuModel] : undefined;
+  const candidateNames: string[] = [];
+
+  if (modelCode && nozzleDiameter) {
+    candidateNames.push(`${bareName} @BBL ${modelCode} ${nozzleDiameter} nozzle`);
+  }
+  if (modelCode) {
+    candidateNames.push(`${bareName} @BBL ${modelCode}`);
+  }
+  candidateNames.push(bareName, baseName);
+
+  const resolvedPaths: string[] = [];
+  let resolution: "exact-model-nozzle" | "model" | "generic" | "unresolved" = "unresolved";
+
+  for (const [candidateIndex, candidateName] of candidateNames.entries()) {
+    const candidatePath = index.byName.get(candidateName);
+    if (!candidatePath || resolvedPaths.includes(candidatePath)) continue;
+    resolvedPaths.push(candidatePath);
+    if (resolution === "unresolved") {
+      if (candidateIndex === 0 && modelCode && nozzleDiameter) {
+        resolution = "exact-model-nozzle";
+      } else if (
+        (candidateIndex === 0 && modelCode && !nozzleDiameter) ||
+        (candidateIndex === 1 && modelCode && nozzleDiameter)
+      ) {
+        resolution = "model";
+      } else {
+        resolution = "generic";
+      }
+    }
+  }
+
+  return { baseName, paths: resolvedPaths, resolution };
+}
+
+function parseIntegerOrNull(value: unknown): number | null {
+  if (value === undefined || value === null || value === "") return null;
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function normalizePrinterFilamentInventory(
+  status: any,
+  bambuModel?: string,
+  nozzleDiameter?: string
+): PrinterFilamentInventory {
+  const rawAms = status?.raw?.ams || status?.ams || {};
+  const trayNow = parseIntegerOrNull(rawAms?.tray_now);
+  const trays: PrinterFilamentInventory["trays"] = [];
+
+  const amsArray = Array.isArray(rawAms?.ams) ? rawAms.ams : [];
+  for (const [amsIndex, amsUnit] of amsArray.entries()) {
+    const trayArray = Array.isArray(amsUnit?.tray) ? amsUnit.tray : [];
+    for (const [trayIndex, tray] of trayArray.entries()) {
+      const amsId = parseIntegerOrNull(amsUnit?.id) ?? amsIndex;
+      const trayId = parseIntegerOrNull(tray?.id) ?? trayIndex;
+      const slot = amsId !== null && trayId !== null ? amsId * 4 + trayId : null;
+      const state = parseIntegerOrNull(tray?.state) ?? 0;
+      const trayInfoIdx = typeof tray?.tray_info_idx === "string" ? tray.tray_info_idx : null;
+      const profileResolution =
+        trayInfoIdx
+          ? resolveFilamentProfileCandidates(trayInfoIdx, bambuModel, nozzleDiameter)
+          : { baseName: null, paths: [], resolution: "unresolved" as const };
+      const resolvedProfilePath = profileResolution.paths[0] || null;
+      const matchConfidence =
+        profileResolution.resolution === "exact-model-nozzle" ? "high" :
+        profileResolution.resolution === "model" ? "medium" :
+        profileResolution.resolution === "generic" ? "low" :
+        "none";
+      const trayType = typeof tray?.tray_type === "string" ? tray.tray_type : null;
+      const traySubBrands = typeof tray?.tray_sub_brands === "string" ? tray.tray_sub_brands : null;
+      const trayColor = typeof tray?.tray_color === "string" ? tray.tray_color : null;
+      const displayParts = [
+        traySubBrands && traySubBrands !== trayType ? traySubBrands : null,
+        trayType,
+        trayColor ? `#${normalizeRgbColor(trayColor) ?? trayColor.replace(/^#/, "").slice(0, 6)}` : null,
+      ].filter(Boolean);
+
+      trays.push({
+        ams_id: amsId,
+        tray_id: trayId,
+        slot,
+        state,
+        loaded: state !== 0 && Boolean(trayInfoIdx),
+        tray_info_idx: trayInfoIdx,
+        tray_type: trayType,
+        tray_sub_brands: traySubBrands,
+        tray_color: trayColor,
+        remain_percent:
+          typeof tray?.remain === "number" && tray.remain >= 0 ? tray.remain : null,
+        nozzle_temp_min: parseIntegerOrNull(tray?.nozzle_temp_min),
+        nozzle_temp_max: parseIntegerOrNull(tray?.nozzle_temp_max),
+        resolved_base_profile_name: profileResolution.baseName,
+        resolved_profile_path: resolvedProfilePath,
+        profile_resolution: profileResolution.resolution,
+        match_confidence: matchConfidence,
+        display_name: displayParts.length > 0 ? displayParts.join(" ") : "empty/unknown",
+        profile_candidates: profileResolution.paths,
+      });
+    }
+  }
+
+  const loadedTrays = trays.filter((tray) => tray.loaded);
+  const recommendedTray =
+    loadedTrays.find((tray) => tray.slot === trayNow && tray.resolved_profile_path) ||
+    loadedTrays.find((tray) => tray.resolved_profile_path) ||
+    null;
+  const recommendedReason =
+    recommendedTray?.slot === trayNow
+      ? "current AMS slot with resolved slicer profile"
+      : recommendedTray
+        ? "first loaded AMS slot with resolved slicer profile"
+        : null;
+
+  const allProfilePaths = Array.from(
+    new Set(
+      loadedTrays
+        .map((tray) => tray.resolved_profile_path)
+        .filter((candidate): candidate is string => Boolean(candidate))
+    )
+  );
+  const emptySlots = trays.filter((tray) => !tray.loaded).length;
+  const resolvedProfileSlots = loadedTrays.filter((tray) => tray.resolved_profile_path).length;
+
+  return {
+    current_slot: trayNow !== null && trayNow >= 0 && trayNow < 254 ? trayNow : null,
+    current_source:
+      trayNow === 254 ? "external" : trayNow !== null && trayNow >= 0 && trayNow < 254 ? "ams" : null,
+    summary: {
+      loaded_slots: loadedTrays.length,
+      resolved_profile_slots: resolvedProfileSlots,
+      unresolved_loaded_slots: loadedTrays.length - resolvedProfileSlots,
+      empty_slots: emptySlots,
+      current_slot: trayNow !== null && trayNow >= 0 && trayNow < 254 ? trayNow : null,
+      current_source:
+        trayNow === 254 ? "external" : trayNow !== null && trayNow >= 0 && trayNow < 254 ? "ams" : null,
+      recommended_slot: recommendedTray?.slot ?? null,
+      recommended_reason: recommendedReason,
+    },
+    trays,
+    recommended: recommendedTray
+      ? {
+          slot: recommendedTray.slot,
+          tray_info_idx: recommendedTray.tray_info_idx,
+          tray_type: recommendedTray.tray_type,
+          resolved_profile_path: recommendedTray.resolved_profile_path,
+          load_filaments: recommendedTray.resolved_profile_path,
+          reason: recommendedReason ?? "resolved slicer profile",
+        }
+      : null,
+    load_filaments_all: allProfilePaths.length > 0 ? allProfilePaths.join(";") : null,
+  };
+}
+
+/**
+ * Normalize a hex color string to lowercase 6-char RGB (drop leading "#"
+ * and any trailing alpha bytes). Returns null if the input doesn't look
+ * like a hex color.
+ *
+ * Bambu mixes formats: 3MF project_settings stores `#FFFFFF` or
+ * `#FF911A80` (RGB or RGBA with leading #). AMS push_status reports
+ * `FFFFFFFF` (RGBA without #). Comparing alpha is risky -- the same
+ * filament can show up as `#000000` in one place and `000000FF` in
+ * another. RGB-only is the right key.
+ */
+function normalizeRgbColor(color: string | null | undefined): string | null {
+  if (!color) return null;
+  const hex = color.replace(/^#/, "").toLowerCase();
+  if (!/^[0-9a-f]{6}([0-9a-f]{2})?$/.test(hex)) return null;
+  return hex.slice(0, 6);
+}
+
+function resolveAmsSlotsFromRequirements(
+  requirements: ThreeMFAmsRequirements,
+  inventory: PrinterFilamentInventory
+): {
+  ams_slots: number[];
+  matches: Array<{ filament_position: number; tray_info_idx: string; slot: number; matched_color?: string | null; match_strategy: "color" | "sku-only" }>;
+  missing: Array<{ filament_position: number; tray_info_idx: string | null; required_color?: string | null; reason: "no_sku" | "no_loaded_match" | "color_mismatch" | "exhausted" }>;
+} {
+  const matches: Array<{ filament_position: number; tray_info_idx: string; slot: number; matched_color?: string | null; match_strategy: "color" | "sku-only" }> = [];
+  const missing: Array<{ filament_position: number; tray_info_idx: string | null; required_color?: string | null; reason: "no_sku" | "no_loaded_match" | "color_mismatch" | "exhausted" }> = [];
+  const amsSlots: number[] = [];
+
+  // Track which AMS slots have already been claimed by an earlier
+  // requirement so two filaments with the same SKU don't collapse onto
+  // the same physical slot.
+  const claimedSlots = new Set<number>();
+
+  for (const filament of requirements.filaments) {
+    if (!filament.tray_info_idx) {
+      missing.push({
+        filament_position: filament.filamentPosition,
+        tray_info_idx: null,
+        required_color: filament.color ?? null,
+        reason: "no_sku",
+      });
+      continue;
+    }
+
+    const requiredColor = normalizeRgbColor(filament.color);
+
+    // Pool of trays loaded with the required SKU that aren't already claimed.
+    const skuPool = inventory.trays.filter(
+      (candidate) =>
+        candidate.loaded &&
+        candidate.slot !== null &&
+        candidate.tray_info_idx === filament.tray_info_idx &&
+        !claimedSlots.has(candidate.slot)
+    );
+
+    if (skuPool.length === 0) {
+      // No trays of this SKU loaded at all (or all already claimed).
+      const reason: "no_loaded_match" | "exhausted" = inventory.trays.some(
+        (t) => t.tray_info_idx === filament.tray_info_idx
+      )
+        ? "exhausted"
+        : "no_loaded_match";
+      missing.push({
+        filament_position: filament.filamentPosition,
+        tray_info_idx: filament.tray_info_idx,
+        required_color: filament.color ?? null,
+        reason,
+      });
+      continue;
+    }
+
+    // Prefer an exact RGB color match. This is what disambiguates
+    // same-SKU different-color cases (e.g. two GFG02 PETG HF trays
+    // loaded -- one black, one white).
+    let chosen = skuPool.find(
+      (candidate) => normalizeRgbColor(candidate.tray_color) === requiredColor && requiredColor !== null
+    );
+    let strategy: "color" | "sku-only" = "color";
+
+    // Fall back to SKU-only when the requirement has no color (legacy
+    // 3MF) or when only one tray of this SKU is loaded (no ambiguity).
+    if (!chosen) {
+      if (!requiredColor || skuPool.length === 1) {
+        chosen = skuPool[0];
+        strategy = "sku-only";
+      } else {
+        // Color was specified, multiple SKU candidates loaded, none
+        // match the requested color. Surface clearly rather than pick
+        // a wrong color silently.
+        missing.push({
+          filament_position: filament.filamentPosition,
+          tray_info_idx: filament.tray_info_idx,
+          required_color: filament.color ?? null,
+          reason: "color_mismatch",
+        });
+        continue;
+      }
+    }
+
+    if (chosen.slot === null) {
+      // Defensive: shouldn't happen because of the filter above, but
+      // keep the type contract honest.
+      missing.push({
+        filament_position: filament.filamentPosition,
+        tray_info_idx: filament.tray_info_idx,
+        required_color: filament.color ?? null,
+        reason: "no_loaded_match",
+      });
+      continue;
+    }
+
+    claimedSlots.add(chosen.slot);
+    amsSlots.push(chosen.slot);
+    matches.push({
+      filament_position: filament.filamentPosition,
+      tray_info_idx: filament.tray_info_idx,
+      slot: chosen.slot,
+      matched_color: chosen.tray_color ?? null,
+      match_strategy: strategy,
+    });
+  }
+
+  return { ams_slots: amsSlots, matches, missing };
+}
+
+function extractPrinterDiagnostics(status: any): Record<string, unknown> {
+  const raw = status?.raw && typeof status.raw === "object" ? status.raw : {};
+  const diagnosticFields: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(raw)) {
+    if (/(hms|error|fail|warn)/i.test(key)) {
+      diagnosticFields[key] = value;
+    }
+  }
+
+  return {
+    connected: Boolean(status?.connected),
+    serial: status?.serial ?? null,
+    printer_status: status?.status ?? null,
+    active_error:
+      raw.print_error ??
+      raw.print_error_code ??
+      raw.mc_print_error_code ??
+      raw.fail_reason ??
+      null,
+    hms: raw.hms ?? raw.hms_info ?? raw.hms_list ?? null,
+    diagnostic_fields: diagnosticFields,
+  };
+}
+
 function validateBambuModel(model: string): string {
   const normalized = model.trim().toLowerCase();
   if (!VALID_BAMBU_MODELS.includes(normalized as BambuModel)) {
@@ -76,9 +515,23 @@ function resolveBedType(argsBedType: string | undefined): string {
   return bedType;
 }
 
+function resolveBambuStudioCliBedType(argsBedType: string | undefined): string {
+  const bedType = resolveBedType(argsBedType);
+  if (!(VALID_BAMBUSTUDIO_CLI_BED_TYPES as readonly string[]).includes(bedType)) {
+    throw new Error(
+      `BambuStudio CLI bed_type "${bedType}" is not verified. Use a pre-sliced 3MF for SuperTack, or choose one of: ${VALID_BAMBUSTUDIO_CLI_BED_TYPES.join(", ")}`
+    );
+  }
+  return bedType;
+}
+
 // Slicer configuration (defaults to bambustudio)
 const DEFAULT_SLICER_TYPE = process.env.SLICER_TYPE || "bambustudio";
-const DEFAULT_SLICER_PROFILE = process.env.SLICER_PROFILE || "";
+const DEFAULT_SLICER_PROFILE = process.env.BAMBU_SLICER_PROFILE || process.env.SLICER_PROFILE || "";
+const DEFAULT_TEMPLATE_3MF_PATH = process.env.BAMBU_TEMPLATE_3MF_PATH || "";
+const DEFAULT_TEMPLATE_DIR =
+  process.env.BAMBU_TEMPLATE_DIR ||
+  path.join(process.env.HOME || process.cwd(), "Sync", "bambu", "templates");
 const SLICER_SCHEMA_VALUES = [
   ...SLICER_TYPES,
   "fulu-orca",
@@ -110,6 +563,9 @@ function defaultSlicerPathFor(slicerType: SlicerType): string {
   }
 
   if (slicerType === "bambustudio") {
+    if (process.env.BAMBU_STUDIO_PATH) {
+      return process.env.BAMBU_STUDIO_PATH;
+    }
     if (process.platform === "darwin") {
       return "/Applications/BambuStudio.app/Contents/MacOS/BambuStudio";
     }
@@ -172,6 +628,57 @@ function parseCsvEnv(value: string | undefined): Set<string> {
   return new Set(value.split(",").map((e) => e.trim()).filter((e) => e.length > 0));
 }
 
+async function resolveSlicerProfilePath(
+  requestedProfile: string | undefined,
+  templatePath: string | undefined,
+  tempDir: string
+): Promise<string | undefined> {
+  if (requestedProfile) {
+    return requestedProfile;
+  }
+
+  if (templatePath) {
+    return resolveTemplateSlicerProfilePath(templatePath, tempDir);
+  }
+
+  return undefined;
+}
+
+async function resolveTemplateSlicerProfilePath(
+  templatePath: string,
+  tempDir: string
+): Promise<string> {
+  const extension = path.extname(templatePath).toLowerCase();
+  if (extension === ".3mf") {
+    return extractBambuTemplateSettings(templatePath, tempDir);
+  }
+  if (extension === ".json" || extension === ".config") {
+    return templatePath;
+  }
+  throw new Error(`Template profile must be a .3mf, .json, or .config file: ${templatePath}`);
+}
+
+function hasExplicitSlicerProfile(args: any): boolean {
+  return typeof args?.slicer_profile === "string" && args.slicer_profile.trim().length > 0;
+}
+
+async function resolveTemplateFirstSlicerProfilePath(
+  args: any,
+  configuredProfile: string | undefined,
+  template3mfPath: string | undefined,
+  tempDir: string
+): Promise<string | undefined> {
+  if (hasExplicitSlicerProfile(args)) {
+    return configuredProfile || undefined;
+  }
+
+  if (template3mfPath) {
+    return resolveTemplateSlicerProfilePath(template3mfPath, tempDir);
+  }
+
+  return configuredProfile || undefined;
+}
+
 function readRuntimeConfig(): RuntimeConfig {
   const rawTransport = process.env.MCP_TRANSPORT?.trim().toLowerCase();
   const transport =
@@ -340,6 +847,157 @@ function redactPrintParams(params: Record<string, unknown>): Record<string, unkn
   };
 }
 
+function parseLooseSlicerConfig(content: string): Record<string, any> {
+  try {
+    return JSON.parse(content);
+  } catch {
+    const config: Record<string, any> = {};
+    for (const line of content.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";")) continue;
+      const separatorIndex = trimmed.indexOf("=");
+      if (separatorIndex === -1) continue;
+      const key = trimmed.slice(0, separatorIndex).trim();
+      const value = trimmed.slice(separatorIndex + 1).trim();
+      if (key) {
+        config[key] = value;
+      }
+    }
+    return config;
+  }
+}
+
+function summarizeSliceSettings(config: Record<string, any>) {
+  return {
+    printer_settings_id:
+      typeof config.printer_settings_id === "string" ? config.printer_settings_id : null,
+    default_print_profile:
+      typeof config.default_print_profile === "string" ? config.default_print_profile : null,
+    default_filament_profile: Array.isArray(config.default_filament_profile)
+      ? config.default_filament_profile
+      : typeof config.default_filament_profile === "string"
+        ? [config.default_filament_profile]
+        : [],
+    filament_settings_id: Array.isArray(config.filament_settings_id)
+      ? config.filament_settings_id.filter((value) => typeof value === "string" && value.length > 0)
+      : [],
+    filament_type: Array.isArray(config.filament_type)
+      ? config.filament_type.filter((value) => typeof value === "string" && value.length > 0)
+      : [],
+    inherits: typeof config.inherits === "string" ? config.inherits : null,
+    print_settings_id: typeof config.print_settings_id === "string" ? config.print_settings_id : null,
+    compatible_printers: Array.isArray(config.compatible_printers)
+      ? config.compatible_printers.filter((value) => typeof value === "string" && value.length > 0)
+      : [],
+    layer_height:
+      config.layer_height !== undefined && config.layer_height !== null
+        ? Number(config.layer_height)
+        : null,
+    first_layer_height:
+      config.initial_layer_print_height !== undefined && config.initial_layer_print_height !== null
+        ? Number(config.initial_layer_print_height)
+        : config.first_layer_height !== undefined && config.first_layer_height !== null
+          ? Number(config.first_layer_height)
+          : null,
+    sparse_infill_density:
+      config.sparse_infill_density !== undefined && config.sparse_infill_density !== null
+        ? String(config.sparse_infill_density)
+        : null,
+    wall_loops:
+      config.wall_loops !== undefined && config.wall_loops !== null
+        ? Number(config.wall_loops)
+        : null,
+    top_shell_layers:
+      config.top_shell_layers !== undefined && config.top_shell_layers !== null
+        ? Number(config.top_shell_layers)
+        : null,
+    bottom_shell_layers:
+      config.bottom_shell_layers !== undefined && config.bottom_shell_layers !== null
+        ? Number(config.bottom_shell_layers)
+        : null,
+    brim_width:
+      config.brim_width !== undefined && config.brim_width !== null
+        ? Number(config.brim_width)
+        : null,
+    support_enabled:
+      config.enable_support !== undefined
+        ? String(config.enable_support) === "1" || String(config.enable_support).toLowerCase() === "true"
+        : config.support_enabled !== undefined
+          ? Boolean(config.support_enabled)
+          : null,
+    support_type: typeof config.support_type === "string" ? config.support_type : null,
+    bed_type:
+      typeof config.curr_bed_type === "string"
+        ? config.curr_bed_type
+        : typeof config.bed_type === "string"
+          ? config.bed_type
+          : null,
+    nozzle_temperature: Array.isArray(config.nozzle_temperature)
+      ? config.nozzle_temperature
+      : config.nozzle_temperature !== undefined
+        ? [config.nozzle_temperature]
+        : [],
+  };
+}
+
+type TemplateEntry = {
+  name: string;
+  path: string;
+  source_type: "3mf" | "json" | "config";
+  relative_path: string;
+};
+type TemplateSourceType = TemplateEntry["source_type"];
+
+function sanitizeTemplateName(templateName: string): string {
+  return templateName
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/^\/+|\/+$/g, "")
+    .replace(/\s+/g, "_")
+    .replace(/[^A-Za-z0-9/_-]/g, "_");
+}
+
+function scanTemplateRegistry(templateDir: string): TemplateEntry[] {
+  if (!fs.existsSync(templateDir)) {
+    return [];
+  }
+
+  const allowedExtensions = new Set([".3mf", ".json", ".config"]);
+  const entries: TemplateEntry[] = [];
+  const stack = [templateDir];
+
+  while (stack.length > 0) {
+    const currentDir = stack.pop()!;
+    for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+
+      const extension = path.extname(entry.name).toLowerCase();
+      if (!allowedExtensions.has(extension)) {
+        continue;
+      }
+
+      const relativePath = path.relative(templateDir, fullPath);
+      const templateName = relativePath
+        .replace(/\\/g, "/")
+        .replace(/(\.gcode)?\.3mf$/i, "")
+        .replace(/\.(json|config)$/i, "");
+
+      entries.push({
+        name: templateName,
+        path: fullPath,
+        source_type: extension === ".3mf" ? "3mf" : extension === ".json" ? "json" : "config",
+        relative_path: relativePath,
+      });
+    }
+  }
+
+  return entries.sort((a, b) => a.name.localeCompare(b.name));
+}
+
 if (!fs.existsSync(TEMP_DIR)) {
   fs.mkdirSync(TEMP_DIR, { recursive: true });
 }
@@ -396,7 +1054,7 @@ class BambuPrinterMCPServer {
       return validateBambuModel(fromArgs);
     }
 
-    // No model from args or env - ask the user via elicitation
+    // No model from args or env — ask the user via elicitation
     try {
       const result = await this.server.elicitInput({
         mode: "form" as const,
@@ -413,11 +1071,13 @@ class BambuPrinterMCPServer {
               oneOf: [
                 { const: "p1s", title: "P1S" },
                 { const: "p1p", title: "P1P" },
+                { const: "p2s", title: "P2S" },
                 { const: "x1c", title: "X1 Carbon" },
                 { const: "x1e", title: "X1E" },
                 { const: "a1", title: "A1" },
                 { const: "a1mini", title: "A1 Mini" },
                 { const: "h2d", title: "H2D" },
+                { const: "h2s", title: "H2S" },
               ],
             },
           },
@@ -433,7 +1093,7 @@ class BambuPrinterMCPServer {
         "Printer model selection was cancelled. Cannot proceed without knowing the printer model."
       );
     } catch (elicitError: any) {
-      // Elicitation not supported by this client - fall back to a clear error
+      // Elicitation not supported by this client — fall back to a clear error
       const msg = elicitError?.message || String(elicitError);
       if (
         elicitError?.code === -32601 || elicitError?.code === -32600 ||
@@ -462,7 +1122,8 @@ class BambuPrinterMCPServer {
   private async ensurePrintableThreeMFPath(
     args: Record<string, any>,
     printModel: string,
-    printPreset: string | undefined
+    printPreset: string | undefined,
+    bedType?: string
   ): Promise<{ threeMFPath: string; autoSliced: boolean }> {
     const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args);
     let threeMFPath = String(args.three_mf_path);
@@ -478,12 +1139,19 @@ class BambuPrinterMCPServer {
       return { threeMFPath, autoSliced: false };
     }
 
+    if (bedType === "supertack_plate") {
+      throw new Error(
+        'BambuStudio CLI SuperTack bed type is not verified; use a pre-sliced 3MF for SuperTack or choose textured_plate, cool_plate, engineering_plate, or hot_plate.'
+      );
+    }
+
     console.log(`3MF has no gcode - auto-slicing with ${slicerType} for ${printModel}`);
     const autoSliceOptions: BambuSliceOptions = {
       uptodate: true,
       ensureOnBed: true,
       minSave: true,
       skipModifiedGcodes: true,
+      bedType: bedType ? resolveBambuStudioCliBedType(bedType) : undefined,
     };
     threeMFPath = await this.stlManipulator.sliceSTL(
       threeMFPath, slicerType, slicerPath, slicerProfile || undefined,
@@ -497,47 +1165,85 @@ class BambuPrinterMCPServer {
 
   private async resolveAmsPrintSettings(
     threeMFPath: string,
-    args: Record<string, any>
-  ): Promise<{ useAMS: boolean; finalAmsMapping?: number[] }> {
+    args: Record<string, any>,
+    host: string,
+    bambuSerial: string,
+    bambuToken: string,
+    printModel?: string,
+    printNozzle?: string
+  ): Promise<{ useAMS: boolean; finalAmsMapping?: number[]; finalAmsSlots?: number[] }> {
     const parsed3MFData = await parse3MF(threeMFPath);
     let parsedAmsMapping: number[] | undefined;
 
     if (parsed3MFData.slicerConfig?.ams_mapping) {
-      const slots = Object.values(parsed3MFData.slicerConfig.ams_mapping)
-        .filter(v => typeof v === 'number') as number[];
+      const slots = normalizeAmsMappingObject(parsed3MFData.slicerConfig.ams_mapping as Record<string, unknown>);
       if (slots.length > 0) {
-        parsedAmsMapping = slots.sort((a, b) => a - b);
+        parsedAmsMapping = slots;
       }
     }
 
     let finalAmsMapping = parsedAmsMapping;
-    const explicitUseAMS = args?.use_ams !== undefined;
-    let useAMS = explicitUseAMS ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
+    let finalAmsSlots: number[] | undefined;
+    let useAMS = args?.use_ams !== undefined ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
+    const hasUserAmsMapping = hasAmsMappingInput(args?.ams_mapping);
+    const hasUserAmsSlots = Array.isArray(args?.ams_slots);
 
-    if (args?.ams_mapping) {
+    if (hasUserAmsMapping) {
       let userMappingOverride: number[] | undefined;
       if (Array.isArray(args.ams_mapping)) {
-        userMappingOverride = args.ams_mapping.filter((v: any) => typeof v === 'number');
-      } else if (typeof args.ams_mapping === 'object') {
-        userMappingOverride = Object.values(args.ams_mapping)
-          .filter((v: any) => typeof v === 'number')
-          .sort((a: any, b: any) => a - b) as number[];
+        userMappingOverride = args.ams_mapping.map((v: unknown, i: number) =>
+          normalizeBridgeAmsTrayValue(v, `ams_mapping[${i}]`)
+        );
+      } else if (args.ams_mapping && typeof args.ams_mapping === 'object') {
+        userMappingOverride = normalizeAmsMappingObject(args.ams_mapping as Record<string, unknown>);
       }
       if (userMappingOverride && userMappingOverride.length > 0) {
         finalAmsMapping = userMappingOverride;
+        finalAmsSlots = undefined;
         useAMS = true;
       }
     }
 
+    if (!hasUserAmsMapping && hasUserAmsSlots) {
+      const userSlots = args.ams_slots.map((slot: unknown, i: number) =>
+        normalizeBridgeAmsTrayValue(slot, `ams_slots[${i}]`)
+      );
+      finalAmsSlots = userSlots;
+      finalAmsMapping = undefined;
+      useAMS = userSlots.length > 0;
+    }
+
+    if (!hasUserAmsMapping && !hasUserAmsSlots && args?.auto_match_ams) {
+      const requirements = await analyze3MFAmsRequirements(
+        threeMFPath,
+        args?.plate_index !== undefined ? Number(args.plate_index) : 0
+      );
+      const inventory = await this.getResolvedPrinterFilamentInventory(
+        host,
+        bambuSerial,
+        bambuToken,
+        printModel,
+        printNozzle
+      );
+      const resolved = resolveAmsSlotsFromRequirements(requirements, inventory);
+      if (resolved.missing.length > 0) {
+        throw new Error(`Could not auto-match AMS slots: ${JSON.stringify(resolved.missing)}`);
+      }
+      finalAmsSlots = resolved.ams_slots;
+      finalAmsMapping = undefined;
+      useAMS = true;
+    }
+
     if (args?.use_ams === false) {
       finalAmsMapping = undefined;
+      finalAmsSlots = undefined;
       useAMS = false;
     }
-    if ((!finalAmsMapping || finalAmsMapping.length === 0) && !explicitUseAMS) {
+    if ((!finalAmsMapping || finalAmsMapping.length === 0) && (!finalAmsSlots || finalAmsSlots.length === 0)) {
       useAMS = false;
     }
 
-    return { useAMS, finalAmsMapping };
+    return { useAMS, finalAmsMapping, finalAmsSlots };
   }
 
   private async print3mfViaBambuNetwork(
@@ -587,14 +1293,27 @@ class BambuPrinterMCPServer {
       throw new Error("bambu_token/access code is required for FULU BambuNetwork LAN/local print methods.");
     }
 
-    const { threeMFPath, autoSliced } = await this.ensurePrintableThreeMFPath(args, printModel, printPreset);
-    const { useAMS, finalAmsMapping } = await this.resolveAmsPrintSettings(threeMFPath, args);
+    const { threeMFPath, autoSliced } = await this.ensurePrintableThreeMFPath(
+      args,
+      printModel,
+      printPreset,
+      printBedType
+    );
+    const { useAMS, finalAmsMapping, finalAmsSlots } = await this.resolveAmsPrintSettings(
+      threeMFPath,
+      args,
+      host,
+      bambuSerial,
+      bambuToken,
+      printModel,
+      printNozzle
+    );
     const threeMfFilename = path.basename(threeMFPath);
     const projectName = String(args?.project_name || threeMfFilename.replace(/\.3mf$/i, ''));
     const presetName = String(args?.preset_name || `${projectName}_plate_${plateIndex + 1}`);
     const clientJobId = args?.client_job_id !== undefined ? Number(args.client_job_id) : Date.now();
 
-    const amsMapping = stringifyBridgeJson(args?.ams_mapping_bridge ?? finalAmsMapping);
+    const amsMapping = stringifyBridgeJson(args?.ams_mapping_bridge ?? finalAmsMapping ?? finalAmsSlots);
     const params: Record<string, unknown> = {
       dev_id: devId,
       task_name: String(args?.task_name || projectName),
@@ -670,11 +1389,259 @@ class BambuPrinterMCPServer {
       plateIndex,
       bridgePlateIndex: plateIndex + 1,
       useAMS,
-      amsMapping: finalAmsMapping,
+      amsMapping: finalAmsMapping ?? finalAmsSlots,
       params: redactPrintParams(params),
     };
   }
 
+  private async getResolvedPrinterFilamentInventory(
+    host: string,
+    bambuSerial: string,
+    bambuToken: string,
+    bambuModel?: string,
+    nozzleDiameter?: string
+  ): Promise<PrinterFilamentInventory> {
+    const status = await this.bambu.getStatus(host, bambuSerial, bambuToken);
+    let inventory = normalizePrinterFilamentInventory(status, bambuModel, nozzleDiameter);
+    // The first MQTT push from an idle printer is sparse (model/modules
+    // only). AMS data arrives on a second push a short while later. If
+    // we have a live connection but no loaded trays, wait for the follow-
+    // up push and retry.
+    if (inventory.trays.length === 0 && status.connected) {
+      await new Promise((r) => setTimeout(r, 1500));
+      const retryStatus = await this.bambu.getStatus(host, bambuSerial, bambuToken);
+      inventory = normalizePrinterFilamentInventory(retryStatus, bambuModel, nozzleDiameter);
+    }
+    return inventory;
+  }
+
+  private async inspectSliceSettings(sourcePath: string) {
+    if (!fs.existsSync(sourcePath)) {
+      throw new Error(`Slice settings source not found: ${sourcePath}`);
+    }
+
+    const extension = path.extname(sourcePath).toLowerCase();
+    const tempDir = path.join(TEMP_DIR, "slice-settings");
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    if (extension === ".3mf") {
+      const parsed = await parse3MF(sourcePath);
+      const extractedSettingsPath = await extractBambuTemplateSettings(sourcePath, tempDir);
+      const config = (parsed.slicerConfig || {}) as Record<string, any>;
+      return {
+        source_path: sourcePath,
+        source_type: "3mf",
+        extracted_settings_path: extractedSettingsPath,
+        object_count: parsed.objects.length,
+        build_item_count: parsed.build.items.length,
+        metadata_keys: Object.keys(parsed.metadata),
+        summary: summarizeSliceSettings(config),
+        raw_key_count: Object.keys(config).length,
+      };
+    }
+
+    const content = fs.readFileSync(sourcePath, "utf8");
+    const config = parseLooseSlicerConfig(content);
+    return {
+      source_path: sourcePath,
+      source_type: extension === ".json" ? "json" : extension === ".config" ? "config" : "text",
+      extracted_settings_path: sourcePath,
+      summary: summarizeSliceSettings(config),
+      raw_key_count: Object.keys(config).length,
+    };
+  }
+
+  private async resolveCollarCharmPrepared3MF(
+    sourcePath: string,
+    template3mfPath: string | undefined,
+    slicerType: SlicerType,
+    slicerPath: string,
+    slicerProfile: string | undefined,
+    printModel: string,
+    printNozzle: string,
+    bedType: string,
+    host: string,
+    bambuSerial: string,
+    bambuToken: string
+  ): Promise<string> {
+    if (!sourcePath.toLowerCase().endsWith(".3mf")) {
+      throw new Error("print_collar_charm requires a prepared .3mf project or sliced 3MF.");
+    }
+
+    try {
+      const JSZip = (await import('jszip')).default;
+      const zipData = fs.readFileSync(sourcePath);
+      const zip = await JSZip.loadAsync(zipData);
+      const hasGcode = Object.keys(zip.files).some(
+        (fileName) => fileName.match(/Metadata\/plate_\d+\.gcode/i) || fileName.endsWith('.gcode')
+      );
+      if (hasGcode) {
+        return sourcePath;
+      }
+    } catch (error: any) {
+      throw new Error(`Failed to inspect collar charm 3MF before slicing: ${error.message}`);
+    }
+
+    const printPreset = BAMBU_MODEL_PRESETS[printModel]?.(printNozzle);
+    if (bedType === "supertack_plate") {
+      throw new Error(
+        'BambuStudio CLI SuperTack bed type is not verified; use a pre-sliced 3MF for SuperTack or choose textured_plate, cool_plate, engineering_plate, or hot_plate.'
+      );
+    }
+    const autoSliceOptions: BambuSliceOptions = {
+      uptodate: true,
+      ensureOnBed: true,
+      minSave: true,
+      skipModifiedGcodes: true,
+      bedType,
+    };
+
+    try {
+      const liveFilaments = await this.getResolvedPrinterFilamentInventory(
+        host,
+        bambuSerial,
+        bambuToken,
+        printModel,
+        printNozzle
+      );
+      if (liveFilaments.recommended?.load_filaments) {
+        autoSliceOptions.loadFilaments = liveFilaments.recommended.load_filaments;
+      }
+    } catch (filamentError) {
+      console.warn("Could not resolve live printer filaments for collar charm auto-slicing:", filamentError);
+    }
+
+    return this.stlManipulator.sliceSTL(
+      sourcePath,
+      slicerType,
+      slicerPath,
+      slicerProfile || template3mfPath || undefined,
+      undefined,
+      printPreset,
+      autoSliceOptions
+    );
+  }
+
+  private async preflightCollarCharmPolicy(
+    host: string,
+    bambuSerial: string,
+    bambuToken: string,
+    bambuModel: string,
+    nozzleDiameter: string
+  ): Promise<PrinterFilamentInventory> {
+    const inventory = await this.getResolvedPrinterFilamentInventory(
+      host,
+      bambuSerial,
+      bambuToken,
+      bambuModel,
+      nozzleDiameter
+    );
+
+    const requiredSlots = [COLLAR_CHARM_POLICY.amsSlots.inner, COLLAR_CHARM_POLICY.amsSlots.outer];
+    for (const slot of requiredSlots) {
+      const tray = inventory.trays.find((candidate) => candidate.slot === slot);
+      if (!tray) {
+        throw new Error(`Collar charm wrapper requires AMS tray ${slot}, but that tray is not reported by the printer.`);
+      }
+      if (!tray.loaded) {
+        throw new Error(`Collar charm wrapper requires AMS tray ${slot} to be loaded, but it is currently empty or unavailable.`);
+      }
+    }
+
+    return inventory;
+  }
+
+  private listTemplateRegistry(templateDir?: string): {
+    template_dir: string;
+    templates: TemplateEntry[];
+  } {
+    const resolvedTemplateDir = templateDir && templateDir.trim().length > 0
+      ? templateDir
+      : DEFAULT_TEMPLATE_DIR;
+    return {
+      template_dir: resolvedTemplateDir,
+      templates: scanTemplateRegistry(resolvedTemplateDir),
+    };
+  }
+
+  private resolveTemplatePath(
+    templateName?: string,
+    templateDir?: string,
+    sourceTypes?: TemplateSourceType[]
+  ): string | undefined {
+    if (!templateName || templateName.trim().length === 0) {
+      return undefined;
+    }
+
+    const registry = this.listTemplateRegistry(templateDir);
+    const normalizedName = sanitizeTemplateName(templateName).toLowerCase();
+    const requestedName = templateName.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").toLowerCase();
+    const nameMatches = registry.templates.filter((entry) =>
+      entry.name.toLowerCase() === requestedName ||
+      sanitizeTemplateName(entry.name).toLowerCase() === normalizedName
+    );
+    const searchTypes = sourceTypes && sourceTypes.length > 0
+      ? sourceTypes
+      : (["3mf", "json", "config"] as TemplateSourceType[]);
+    const match = searchTypes
+      .map((sourceType) => nameMatches.find((entry) => entry.source_type === sourceType))
+      .find((entry): entry is TemplateEntry => Boolean(entry));
+    if (!match) {
+      const typeHint = sourceTypes && sourceTypes.length > 0
+        ? ` with source type ${sourceTypes.join("/")}`
+        : "";
+      const availableTypes = nameMatches.length > 0
+        ? ` Available source types: ${Array.from(new Set(nameMatches.map((entry) => entry.source_type))).join(", ")}.`
+        : "";
+      throw new Error(
+        `Template "${templateName}"${typeHint} not found in ${registry.template_dir}.${availableTypes}`
+      );
+    }
+
+    return match.path;
+  }
+
+  private saveTemplate(sourcePath: string, templateName?: string, templateDir?: string) {
+    if (!fs.existsSync(sourcePath)) {
+      throw new Error(`Template source not found: ${sourcePath}`);
+    }
+
+    const resolvedTemplateDir = templateDir && templateDir.trim().length > 0
+      ? templateDir
+      : DEFAULT_TEMPLATE_DIR;
+    fs.mkdirSync(resolvedTemplateDir, { recursive: true });
+
+    const sourceBaseName = path.basename(sourcePath);
+    const extension = path.extname(sourceBaseName).toLowerCase();
+    if (![".3mf", ".json", ".config"].includes(extension)) {
+      throw new Error("Templates must be .3mf, .json, or .config files.");
+    }
+
+    const baseName = templateName && templateName.trim().length > 0
+      ? sanitizeTemplateName(templateName)
+      : sanitizeTemplateName(
+          sourceBaseName
+            .replace(/(\.gcode)?\.3mf$/i, "")
+            .replace(/\.(json|config)$/i, "")
+        );
+
+    const destinationPath = path.join(resolvedTemplateDir, `${baseName}${extension}`);
+    fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+    fs.copyFileSync(sourcePath, destinationPath);
+
+    const sourceType: TemplateSourceType =
+      extension === ".3mf" ? "3mf" : extension === ".json" ? "json" : "config";
+    const registryEntry = this.resolveTemplatePath(baseName, resolvedTemplateDir, [sourceType]);
+    return {
+      saved: true,
+      template_name: baseName,
+      source_path: sourcePath,
+      destination_path: destinationPath,
+      template_dir: resolvedTemplateDir,
+      resolved_path: registryEntry,
+    };
+  }
+
   setupResourceHandlers() {
     this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
       return {
@@ -690,6 +1657,12 @@ class BambuPrinterMCPServer {
             name: "Bambu Printer Files",
             mimeType: "application/json",
             description: "List of files on the Bambu Lab printer"
+          },
+          {
+            uri: `printer://${DEFAULT_HOST}/hms`,
+            name: "Bambu Printer HMS Diagnostics",
+            mimeType: "application/json",
+            description: "HMS and error-related fields from the latest printer status"
           }
         ],
         templates: [
@@ -702,6 +1675,11 @@ class BambuPrinterMCPServer {
             uriTemplate: "printer://{host}/files",
             name: "Bambu Printer Files",
             mimeType: "application/json"
+          },
+          {
+            uriTemplate: "printer://{host}/hms",
+            name: "Bambu Printer HMS Diagnostics",
+            mimeType: "application/json"
           }
         ]
       };
@@ -724,6 +1702,19 @@ class BambuPrinterMCPServer {
         content = await this.bambu.getStatus(host || DEFAULT_HOST, bambuSerial, bambuToken);
       } else if (resource === "files") {
         content = await this.bambu.getFiles(host || DEFAULT_HOST, bambuSerial, bambuToken);
+      } else if (resource === "hms") {
+        const status = await this.bambu.getStatus(host || DEFAULT_HOST, bambuSerial, bambuToken);
+        let diagnostics = extractPrinterDiagnostics(status);
+        // The first MQTT status push may not include HMS data — the printer
+        // sends basic state first, then pushes HMS/error fields on a subsequent
+        // report. If we got a connection but no HMS data, wait briefly and
+        // retry so the incremental merge has time to arrive.
+        if (!diagnostics.hms && status.connected) {
+          await new Promise((r) => setTimeout(r, 1500));
+          const retryStatus = await this.bambu.getStatus(host || DEFAULT_HOST, bambuSerial, bambuToken);
+          diagnostics = extractPrinterDiagnostics(retryStatus);
+        }
+        content = diagnostics;
       } else {
         throw new McpError(ErrorCode.InvalidRequest, `Unknown resource: ${resource}`);
       }
@@ -766,15 +1757,78 @@ class BambuPrinterMCPServer {
             }
           },
           {
-            name: "extend_stl_base",
-            description: "Extend the base of an STL file by a specified amount",
+            name: "get_printer_filaments",
+            description: "Get the live AMS/external filament inventory from the printer over MQTT, including loaded/empty slot summary, resolved slicer profile paths, match confidence, and recommended load_filaments when the printer model is known.",
             inputSchema: {
               type: "object",
               properties: {
-                stl_path: { type: "string", description: "Path to the STL file to modify" },
-                extension_height: { type: "number", description: "Height in mm to extend the base by" }
-              },
-              required: ["stl_path", "extension_height"]
+                host: {
+                  type: "string",
+                  description: "Hostname or IP address of the printer (default: value from env)"
+                },
+                bambu_serial: {
+                  type: "string",
+                  description: "Serial number for the Bambu Lab printer (default: value from env)"
+                },
+                bambu_token: {
+                  type: "string",
+                  description: "Access token for the Bambu Lab printer (default: value from env)"
+                },
+                bambu_model: {
+                  type: "string",
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                  description: "Optional model hint used to resolve Bambu/Orca filament profile JSONs for each tray."
+                },
+                nozzle_diameter: {
+                  type: "string",
+                  description: "Optional nozzle diameter used when resolving model-specific filament profile JSONs (default: 0.4)."
+                }
+              }
+            }
+          },
+          {
+            name: "resolve_3mf_ams_slots",
+            description: "Inspect a sliced 3MF and match its tray_info_idx filament requirements against the live AMS inventory. Does not upload or start a print.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                three_mf_path: { type: "string", description: "Path to a sliced 3MF/.gcode.3mf file" },
+                plate_index: { type: "number", description: "0-based plate index to inspect (default: 0)" },
+                bambu_model: {
+                  type: "string",
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                  description: "Optional model hint used to resolve Bambu/Orca filament profile JSONs for each tray."
+                },
+                nozzle_diameter: { type: "string", description: "Nozzle diameter in mm (default: 0.4)" },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["three_mf_path"]
+            }
+          },
+          {
+            name: "list_3mf_plate_objects",
+            description: "List object IDs from a sliced 3MF plate. Use these IDs with skip_objects during a running print.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                three_mf_path: { type: "string", description: "Path to a sliced 3MF/.gcode.3mf file" },
+                plate_index: { type: "number", description: "0-based plate index to inspect (default: 0)" }
+              },
+              required: ["three_mf_path"]
+            }
+          },
+          {
+            name: "extend_stl_base",
+            description: "Extend the base of an STL file by a specified amount",
+            inputSchema: {
+              type: "object",
+              properties: {
+                stl_path: { type: "string", description: "Path to the STL file to modify" },
+                extension_height: { type: "number", description: "Height in mm to extend the base by" }
+              },
+              required: ["stl_path", "extension_height"]
             }
           },
           {
@@ -816,6 +1870,110 @@ class BambuPrinterMCPServer {
               required: ["stl_path"]
             }
           },
+          {
+            name: "list_templates",
+            description: "List saved slicing templates from the local template registry directory.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                template_dir: {
+                  type: "string",
+                  description: "Optional template directory override. Defaults to BAMBU_TEMPLATE_DIR or the server's configured local template registry."
+                }
+              }
+            }
+          },
+          {
+            name: "save_template",
+            description: "Copy a 3MF, JSON, or config file into the local template registry and register it under a template name.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                source_path: {
+                  type: "string",
+                  description: "Path to a local .3mf, .json, or .config file to save into the template registry."
+                },
+                template_name: {
+                  type: "string",
+                  description: "Optional template name. Defaults to the source filename without extension."
+                },
+                template_dir: {
+                  type: "string",
+                  description: "Optional template directory override. Defaults to BAMBU_TEMPLATE_DIR or the server's configured local template registry."
+                }
+              },
+              required: ["source_path"]
+            }
+          },
+          {
+            name: "get_slice_settings",
+            description: "Inspect slicer settings from a saved 3MF template or a JSON/config slicer profile without slicing anything.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                source_path: {
+                  type: "string",
+                  description: "Path to a 3MF template, extracted project_settings.config, or slicer profile JSON."
+                },
+                template_name: {
+                  type: "string",
+                  description: "Optional named template from the local registry. If provided, resolves source_path automatically."
+                },
+                template_dir: {
+                  type: "string",
+                  description: "Optional template directory override when resolving template_name."
+                }
+              }
+            }
+          },
+          {
+            name: "slice_with_template",
+            description: "Slice an STL or 3MF using a named template from the local registry. This is a higher-level wrapper around slice_stl for template-based workflows.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                stl_path: { type: "string", description: "Path to the STL or 3MF file to slice" },
+                template_name: { type: "string", description: "Named template from the local registry." },
+                template_dir: { type: "string", description: "Optional template directory override when resolving template_name." },
+                bambu_model: {
+                  type: "string",
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                  description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
+                },
+                slicer_type: {
+                  type: "string",
+                  enum: SLICER_SCHEMA_VALUES,
+                  description: "Type of slicer to use. Bambu-compatible choices (bambustudio, orcaslicer, orcaslicer-bambulab) export sliced 3MF; aliases such as fulu-orca and orca-studio are accepted."
+                },
+                slicer_path: { type: "string", description: "Path to the slicer executable (default: value from env)" },
+                slicer_profile: { type: "string", description: "Explicit slicer profile/config file. Overrides the named template only when provided in the tool call." },
+                nozzle_diameter: { type: "string", description: "Nozzle diameter in mm (default: 0.4)" },
+                bed_type: {
+                  type: "string",
+                  enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"],
+                  description: "Bed plate type for slicing (default: textured_plate). SuperTack is accepted only for pre-sliced print jobs until the BambuStudio CLI identifier is verified."
+                },
+                use_printer_filaments: { type: "boolean", description: "When true, and no explicit slicer profile or load_filaments override is provided, use the printer's current or first loaded AMS filament as the slicer filament profile." },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" },
+                load_filaments: { type: "string", description: "Override filament profiles. Semicolon-separated paths to filament JSON configs." },
+                load_filament_ids: { type: "string", description: "Optional filament-to-object mapping string." },
+                ensure_on_bed: { type: "boolean", description: "Lift floating models onto the bed." },
+                arrange: { type: "boolean", description: "Auto-arrange objects on the build plate." },
+                orient: { type: "boolean", description: "Auto-orient model for optimal printability." },
+                repetitions: { type: "number", description: "Number of copies to print." },
+                scale: { type: "number", description: "Uniform scale factor." },
+                rotate: { type: "number", description: "Z-axis rotation in degrees." },
+                rotate_x: { type: "number", description: "X-axis rotation in degrees." },
+                rotate_y: { type: "number", description: "Y-axis rotation in degrees." },
+                min_save: { type: "boolean", description: "Produce smaller output 3MF." },
+                skip_modified_gcodes: { type: "boolean", description: "Ignore stale custom gcodes in the 3MF." },
+                slice_plate: { type: "number", description: "Which plate index to slice. 0 = all plates." }
+              },
+              required: ["stl_path", "template_name", "bambu_model"]
+            }
+          },
           {
             name: "slice_stl",
             description: "Slice an STL or 3MF file using a slicer to generate printable G-code or sliced 3MF. IMPORTANT: bambu_model must be specified to ensure the slicer generates safe G-code for the correct printer.",
@@ -825,7 +1983,7 @@ class BambuPrinterMCPServer {
                 stl_path: { type: "string", description: "Path to the STL or 3MF file to slice" },
                 bambu_model: {
                   type: "string",
-                  enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
                   description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
                 },
                 slicer_type: {
@@ -833,10 +1991,19 @@ class BambuPrinterMCPServer {
                   enum: SLICER_SCHEMA_VALUES,
                   description: "Type of slicer to use. Bambu-compatible choices (bambustudio, orcaslicer, orcaslicer-bambulab) export sliced 3MF; aliases such as fulu-orca and orca-studio are accepted."
                 },
-                slicer_path: { type: "string", description: "Path to the slicer executable (default: value from env or a platform default)" },
+                slicer_path: { type: "string", description: "Path to the slicer executable (default: value from env)" },
                 slicer_profile: { type: "string", description: "Path to the slicer profile/config file (optional, overrides bambu_model preset)" },
+                template_3mf_path: { type: "string", description: "Optional template 3MF whose embedded Bambu slicer settings should be reused when slicing a new STL or 3MF." },
+                template_name: { type: "string", description: "Optional named template from the local registry. Resolves to template_3mf_path automatically." },
+                template_dir: { type: "string", description: "Optional template directory override when resolving template_name." },
                 nozzle_diameter: { type: "string", description: "Nozzle diameter in mm (default: 0.4)" },
-                uptodate: { type: "boolean", description: "Refresh 3MF preset configs to match the latest Bambu-compatible slicer presets. Use when slicing downloaded or older 3MF files to prevent stale-config failures." },
+                bed_type: {
+                  type: "string",
+                  enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"],
+                  description: "Bed plate type for slicing (default: textured_plate). SuperTack is accepted only for pre-sliced print jobs until the BambuStudio CLI identifier is verified."
+                },
+                use_printer_filaments: { type: "boolean", description: "When true, and no explicit slicer profile or load_filaments override is provided, use the printer's current or first loaded AMS filament as the slicer filament profile. Template 3MF process settings can still be used at the same time." },
+                uptodate: { type: "boolean", description: "Refresh 3MF preset configs to match the latest BambuStudio version. Use when slicing downloaded or older 3MF files to prevent stale-config failures." },
                 repetitions: { type: "number", description: "Print N identical copies of the model. Each copy gets its own plate placement. Example: 3 prints three copies." },
                 orient: { type: "boolean", description: "Auto-orient the model for optimal printability (minimize supports, maximize bed adhesion). Recommended for raw STL imports that lack a pre-set orientation." },
                 arrange: { type: "boolean", description: "Auto-arrange all objects on the build plate with optimal spacing. Recommended when importing STLs or adding multiple objects. Set false to preserve existing plate layout." },
@@ -844,7 +2011,7 @@ class BambuPrinterMCPServer {
                 clone_objects: { type: "string", description: "Duplicate specific objects on the plate. Comma-separated clone counts per object index, e.g. '1,3,1,10' clones object 0 once, object 1 three times, etc." },
                 skip_objects: { type: "string", description: "Skip specific objects during slicing by index. Comma-separated, e.g. '3,5,10'. Useful for multi-object 3MFs where you only want to print some parts." },
                 load_filaments: { type: "string", description: "Override filament profiles. Semicolon-separated paths to filament JSON configs, e.g. 'pla_basic.json;petg_cf.json'." },
-                filament_profile: { type: "string", description: "Compatibility alias for load_filaments. Semicolon-separated Orca/Bambu filament profile JSON paths; flat self-contained profiles are safest because Orca does not resolve every inherited system filament setting from arbitrary file paths." },
+                filament_profile: { type: "string", description: "Compatibility alias for load_filaments. Semicolon-separated Orca/Bambu filament profile JSON paths." },
                 load_filament_ids: { type: "string", description: "Map filaments to objects/parts. Comma-separated IDs matching load_filaments order, e.g. '1,2,3,1' assigns filament 1 to objects 0 and 3." },
                 enable_timelapse: { type: "boolean", description: "Insert timelapse parking moves into gcode. The toolhead parks at a fixed position each layer for camera capture. Adds ~10% print time." },
                 allow_mix_temp: { type: "boolean", description: "Allow filaments with different temperature requirements on the same plate. Required for multi-material prints mixing e.g. PLA and PETG." },
@@ -913,7 +2080,7 @@ class BambuPrinterMCPServer {
                 three_mf_path: { type: "string", description: "Path to the 3MF file to print; unsliced 3MFs are auto-sliced before sending." },
                 bambu_model: {
                   type: "string",
-                  enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
                   description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
                 },
                 connection_type: { type: "string", enum: ["cloud", "lan"], description: "BambuNetwork connection type to put in FULU PrintParams; cloud uses restored internet printing, lan uses local bridge printing." },
@@ -925,7 +2092,7 @@ class BambuPrinterMCPServer {
                 bambu_token: { type: "string", description: "Printer access code/password for LAN/local bridge methods." },
                 username: { type: "string", description: "Printer username for LAN/local bridge methods; defaults to bblp." },
                 password: { type: "string", description: "Printer password/access code override for LAN/local bridge methods." },
-                bed_type: { type: "string", enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"], description: "Bed plate type currently installed (default: textured_plate)." },
+                bed_type: { type: "string", enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"], description: "Bed plate type currently installed (default: textured_plate)." },
                 plate_index: { type: "number", description: "Zero-based plate index to print from the sliced 3MF; converted to FULU's one-based PrintParams plate_index." },
                 project_name: { type: "string", description: "Optional project name sent in FULU PrintParams; defaults to the 3MF filename without extension." },
                 preset_name: { type: "string", description: "Optional preset name sent in FULU PrintParams; defaults to project plus one-based plate index." },
@@ -942,6 +2109,7 @@ class BambuPrinterMCPServer {
                 nozzle_diameter: { type: "string", description: "Nozzle diameter in mm for auto-slicing (default: 0.4)." },
                 use_ams: { type: "boolean", description: "Whether to use the AMS; defaults to auto-detect from the 3MF mapping." },
                 ams_mapping: { type: "array", description: "AMS slot mapping array used by both local MCP printing and FULU PrintParams.", items: { type: "number" } },
+                ams_slots: { type: "array", description: "Per-used-filament AMS slot list, matching the local LAN print path.", items: { type: "number" } },
                 ams_mapping_bridge: { type: "string", description: "Raw JSON string override for FULU PrintParams ams_mapping when the automatic array is not enough." },
                 ams_mapping2: { type: "string", description: "Raw JSON string for FULU PrintParams ams_mapping2, matching OrcaSlicer-bambulab's v1 AMS mapping field." },
                 ams_mapping_info: { type: "string", description: "Raw JSON string for FULU PrintParams ams_mapping_info, matching OrcaSlicer-bambulab's detailed AMS mapping field." },
@@ -962,6 +2130,44 @@ class BambuPrinterMCPServer {
               required: ["three_mf_path", "bambu_model"]
             }
           },
+          {
+            name: "camera_snapshot",
+            description: "Capture a single JPEG frame from the printer's chamber camera. A1/P1 use TCP-on-6000; X1/P2S/H2 use RTSP via ffmpeg. Returns JPEG as base64; pass save_path to also write the bytes to disk.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                save_path: { type: "string", description: "Optional absolute path to write the JPEG to disk. If omitted, only the base64 payload is returned." },
+                timeout_ms: { type: "number", description: "Max ms to wait for a full frame (default 8000). Camera may take a few seconds on cold start." },
+                bambu_model: { type: "string", description: "Printer model. Used to route to the correct protocol or fail fast on unsupported models. Defaults to BAMBU_MODEL." },
+                experimental: { type: "boolean", description: "Deprecated and ignored. Earlier this flag let callers probe H2 series via the A1/P1 TCP-on-6000 path; live testing on an H2S confirmed H2 uses RTSP instead, so the flag has no effect now." },
+                ffmpeg_path: { type: "string", description: "Override path to the ffmpeg binary used by the RTSP path. Defaults to ffmpeg via $PATH. Required only for the RTSP transport (X1, P2S, H2 series)." },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              }
+            }
+          },
+          {
+            name: "delete_printer_file",
+            description: "Delete a file from the Bambu Lab printer's SD card via FTPS. Destructive: requires confirm:true. Restricted to cache/, timelapse/, and logs/ directories. Path traversal segments (..) are rejected.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                filename: {
+                  type: "string",
+                  description: "File to delete. Bare names default to cache/<name>; pass a relative path like timelapse/foo.mp4 to target other allowed directories."
+                },
+                confirm: {
+                  type: "boolean",
+                  description: "Must be true to actually delete. When false or omitted the call returns without sending an FTP request."
+                },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["filename"]
+            }
+          },
           {
             name: "upload_gcode",
             description: "Upload a G-code file to the Bambu Lab printer",
@@ -969,17 +2175,13 @@ class BambuPrinterMCPServer {
               type: "object",
               properties: {
                 filename: { type: "string", description: "Name for the file on the printer" },
-                gcode: { type: "string", description: "G-code content to upload, or a readable local .gcode path. For large files, prefer gcode_path." },
-                gcode_path: { type: "string", description: "Local path to a .gcode file to upload. This avoids sending large G-code bodies through the MCP request." },
+                gcode: { type: "string", description: "G-code content to upload, or a readable local .gcode path. Required unless gcode_path is provided. For large files, prefer gcode_path." },
+                gcode_path: { type: "string", description: "Local path to a .gcode file to upload. Required unless gcode is provided. This avoids sending large G-code bodies through the MCP request." },
                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
                 bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
                 bambu_token: { type: "string", description: "Access token (default: value from env)" }
               },
-              required: ["filename"],
-              anyOf: [
-                { required: ["gcode"] },
-                { required: ["gcode_path"] }
-              ]
+              required: ["filename"]
             }
           },
           {
@@ -993,7 +2195,7 @@ class BambuPrinterMCPServer {
                 print: { type: "boolean", description: "Start printing after upload (default: false)" },
                 bambu_model: {
                   type: "string",
-                  enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
                   description: "Required when print is true. Bambu Lab printer model used as a safety confirmation before starting the uploaded file."
                 },
                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
@@ -1012,7 +2214,7 @@ class BambuPrinterMCPServer {
                 filename: { type: "string", description: "Name of the file to print" },
                 bambu_model: {
                   type: "string",
-                  enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
                   description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Starting G-code for the wrong model can damage the printer."
                 },
                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
@@ -1031,7 +2233,7 @@ class BambuPrinterMCPServer {
                 filename: { type: "string", description: "Name of the file to print" },
                 bambu_model: {
                   type: "string",
-                  enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
                   description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Starting G-code for the wrong model can damage the printer."
                 },
                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
@@ -1053,6 +2255,93 @@ class BambuPrinterMCPServer {
               }
             }
           },
+          {
+            name: "pause_print",
+            description: "Pause the current print job on the Bambu Lab printer (resumable via resume_print)",
+            inputSchema: {
+              type: "object",
+              properties: {
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              }
+            }
+          },
+          {
+            name: "resume_print",
+            description: "Resume a paused print job on the Bambu Lab printer",
+            inputSchema: {
+              type: "object",
+              properties: {
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              }
+            }
+          },
+          {
+            name: "clear_hms_errors",
+            description: "Clear HMS or print error state on the Bambu Lab printer using the clean_print_error MQTT command.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              }
+            }
+          },
+          {
+            name: "set_print_speed",
+            description: "Set the active print speed mode: silent, standard, sport, or ludicrous.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                mode: {
+                  type: "string",
+                  enum: ["silent", "standard", "sport", "ludicrous", "1", "2", "3", "4"],
+                  description: "Speed mode to apply: silent/1, standard/2, sport/3, or ludicrous/4"
+                },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["mode"]
+            }
+          },
+          {
+            name: "set_airduct_mode",
+            description: "Set H2/P2 airduct mode to cooling or heating.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                mode: {
+                  type: "string",
+                  enum: ["cooling", "heating"],
+                  description: "Airduct mode to apply"
+                },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["mode"]
+            }
+          },
+          {
+            name: "reread_ams_rfid",
+            description: "Trigger a Bambu AMS RFID re-read for one AMS slot. This can move AMS filament; use only when the printer is idle and unloaded.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                ams_id: { type: "number", description: "AMS unit index from 0 to 3" },
+                slot_id: { type: "number", description: "Slot index within that AMS, from 0 to 3" },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["ams_id", "slot_id"]
+            }
+          },
           {
             name: "set_temperature",
             description: "Set the temperature of a printer component (bed, nozzle)",
@@ -1068,6 +2357,86 @@ class BambuPrinterMCPServer {
               required: ["component", "temperature"]
             }
           },
+          {
+            name: "set_fan_speed",
+            description: "Set a Bambu printer fan speed percentage using the printer's MQTT fan command",
+            inputSchema: {
+              type: "object",
+              properties: {
+                fan: {
+                  type: "string",
+                  description: "Fan to control: part, auxiliary, chamber, 1, 2, or 3"
+                },
+                speed: { type: "number", description: "Fan speed percentage from 0 to 100" },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["fan", "speed"]
+            }
+          },
+          {
+            name: "set_light",
+            description: "Set a Bambu printer light node mode using the printer's MQTT LED command",
+            inputSchema: {
+              type: "object",
+              properties: {
+                light: {
+                  type: "string",
+                  description: "Light node to control, for example chamber_light"
+                },
+                mode: {
+                  type: "string",
+                  enum: ["on", "off", "flashing"],
+                  description: "Light mode to apply"
+                },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["light", "mode"]
+            }
+          },
+          {
+            name: "skip_objects",
+            description: "Skip specific object IDs during a running multi-object print using the printer's MQTT skip_objects command",
+            inputSchema: {
+              type: "object",
+              properties: {
+                object_ids: {
+                  type: "array",
+                  description: "Object IDs to skip. Use list_3mf_plate_objects on the sliced 3MF to find IDs.",
+                  items: { type: "number" }
+                },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["object_ids"]
+            }
+          },
+          {
+            name: "set_ams_drying",
+            description: "Start or stop the AMS filament drying cycle. Available on AMS units with heating capability (AMS Pro / AMS-HT). Sends an ams_control MQTT command to the printer.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                action: {
+                  type: "string",
+                  enum: ["start", "stop"],
+                  description: "Whether to start or stop the drying cycle"
+                },
+                ams_id: {
+                  type: "number",
+                  description: "AMS unit index from 0 to 3"
+                },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" }
+              },
+              required: ["action", "ams_id"]
+            }
+          },
           {
             name: "print_3mf",
             description: "Print a 3MF file on a Bambu Lab printer. Auto-slices if the 3MF has no gcode. IMPORTANT: bambu_model must be specified to ensure safe printer operation.",
@@ -1077,13 +2446,13 @@ class BambuPrinterMCPServer {
                 three_mf_path: { type: "string", description: "Path to the 3MF file to print" },
                 bambu_model: {
                   type: "string",
-                  enum: ["p1s", "p1p", "x1c", "x1e", "a1", "a1mini", "h2d"],
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
                   description: "REQUIRED: Bambu Lab printer model. Ask the user if not known. Using the wrong model can damage the printer."
                 },
                 connection_mode: {
                   type: "string",
                   enum: ["lan_mqtt_ftps", "bambu_network"],
-                  description: "Print path to use: lan_mqtt_ftps uses this MCP's direct local MQTT/FTPS path; bambu_network uses FULU OrcaSlicer-bambulab's restored BambuNetwork bridge."
+                  description: "Print path to use: lan_mqtt_ftps uses this MCP's direct local MQTT/FTPS path; bambu_network uses the restored FULU BambuNetwork bridge."
                 },
                 connection_type: { type: "string", enum: ["cloud", "lan"], description: "BambuNetwork connection type when connection_mode is bambu_network; cloud uses restored internet printing, lan uses local bridge printing." },
                 bambu_network_method: { type: "string", enum: BAMBU_NETWORK_PRINT_METHODS, description: "FULU print method when connection_mode is bambu_network; defaults to start_print for cloud and start_local_print for lan." },
@@ -1095,34 +2464,77 @@ class BambuPrinterMCPServer {
                 user_info: { type: "string", description: "Optional BambuNetwork user_info JSON string passed to net.change_user for the FULU bridge." },
                 bed_type: {
                   type: "string",
-                  enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate"],
+                  enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"],
                   description: "Bed plate type currently installed (default: textured_plate)"
                 },
-                plate_index: { type: "number", description: "Zero-based plate index to print from the sliced 3MF (default: 0)" },
                 host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
                 bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
                 bambu_token: { type: "string", description: "Access token (default: value from env)" },
+                plate_index: { type: "number", description: "Zero-based plate index to print from the sliced 3MF (default: 0)" },
                 slicer_type: {
                   type: "string",
                   enum: SLICER_SCHEMA_VALUES,
-                  description: "Slicer to use only if auto-slicing an unsliced 3MF. Use orcaslicer-bambulab for FULU's OrcaSlicer-bambulab fork; aliases such as fulu-orca and orca-studio are accepted."
+                  description: "Slicer to use only if auto-slicing an unsliced 3MF. Bambu-compatible slicer aliases such as fulu-orca and orca-studio are accepted."
                 },
                 slicer_path: { type: "string", description: "Path to the slicer executable for auto-slicing (default: value from env or a platform default)" },
-                slicer_profile: { type: "string", description: "Path to an optional slicer profile/config file for auto-slicing" },
                 use_ams: { type: "boolean", description: "Whether to use the AMS (default: auto-detect from 3MF)" },
                 ams_mapping: {
                   type: "array",
-                  description: "AMS slot mapping array, e.g. [0, 2] maps filaments to AMS slots 0 and 2",
+                  description: "Project-level AMS mapping array. Position = project filament index, value = absolute AMS tray (0-3=AMS 0, 4-7=AMS 1, 8-11=AMS 2, 128+=AMS-HT, 254=external, -1=unused). Prefer ams_slots unless you know the project-level layout.",
                   items: { type: "number" }
                 },
+                ams_slots: {
+                  type: "array",
+                  description: "Preferred AMS input: one absolute tray index per USED filament in plate order, e.g. [1] for a single-filament print pulling from AMS 0 slot 1. Expanded to project-level ams_mapping automatically from the 3MF's plate_N.json and gcode header.",
+                  items: { type: "number" }
+                },
+                auto_match_ams: {
+                  type: "boolean",
+                  description: "When true, match the sliced 3MF's tray_info_idx requirements against live AMS inventory and use the resulting ams_slots. Ignored when ams_mapping or ams_slots is provided."
+                },
+                bed_leveling: { type: "boolean", description: "Enable auto bed leveling (default: true)" },
+                                flow_calibration: { type: "boolean", description: "Enable flow calibration (default: true)" },
+                                vibration_calibration: { type: "boolean", description: "Enable vibration calibration (default: true)" },
+                                timelapse: { type: "boolean", description: "Enable timelapse recording (default: false)" },
+                                slicer_profile: { type: "string", description: "Path to the slicer profile/config file for auto-slicing (optional)." },
+                                template_3mf_path: { type: "string", description: "Optional template 3MF whose embedded Bambu slicer settings should be reused when auto-slicing this print job." },
+                                template_name: { type: "string", description: "Optional named template from the local registry. Resolves to template_3mf_path automatically." },
+                                template_dir: { type: "string", description: "Optional template directory override when resolving template_name." },
+                                nozzle_diameter: { type: "string", description: "Nozzle diameter in mm for auto-slicing (default: 0.4)" }
+                              },
+              required: ["three_mf_path", "bambu_model"]
+            }
+          },
+          {
+            name: "print_collar_charm",
+            description: "Print a prepared two-part dog collar charm project using the fixed tray policy: inner/smaller object -> black on AMS 1 slot 1, outer/larger object -> white on AMS 2 slot 1.",
+            inputSchema: {
+              type: "object",
+              properties: {
+                source_path: { type: "string", description: "Path to a prepared collar charm .3mf project or sliced 3MF. Required unless template_name is provided." },
+                template_name: { type: "string", description: "Named collar charm template from the local registry. Required unless source_path is provided; resolves source_path automatically." },
+                template_dir: { type: "string", description: "Optional template directory override when resolving template_name." },
+                bambu_model: {
+                  type: "string",
+                  enum: ["p1s", "p1p", "p2s", "x1c", "x1e", "a1", "a1mini", "h2d", "h2s"],
+                  description: "REQUIRED: Bambu Lab printer model. H2D and H2S are the primary intended paths."
+                },
+                host: { type: "string", description: "Hostname or IP of the printer (default: value from env)" },
+                bambu_serial: { type: "string", description: "Serial number (default: value from env)" },
+                bambu_token: { type: "string", description: "Access token (default: value from env)" },
+                bed_type: {
+                  type: "string",
+                  enum: ["textured_plate", "cool_plate", "engineering_plate", "hot_plate", "supertack_plate"],
+                  description: "Bed plate type currently installed (default: textured_plate)"
+                },
                 bed_leveling: { type: "boolean", description: "Enable auto bed leveling (default: true)" },
                 flow_calibration: { type: "boolean", description: "Enable flow calibration (default: true)" },
                 vibration_calibration: { type: "boolean", description: "Enable vibration calibration (default: true)" },
-                layer_inspect: { type: "boolean", description: "Enable first-layer inspection where supported (default: printer/profile behavior)" },
                 timelapse: { type: "boolean", description: "Enable timelapse recording (default: false)" },
+                slicer_profile: { type: "string", description: "Path to the slicer profile/config file for auto-slicing (optional)." },
                 nozzle_diameter: { type: "string", description: "Nozzle diameter in mm for auto-slicing (default: 0.4)" }
               },
-              required: ["three_mf_path", "bambu_model"]
+              required: ["bambu_model"]
             }
           },
           {
@@ -1187,6 +2599,16 @@ class BambuPrinterMCPServer {
       const host = String(args?.host || DEFAULT_HOST);
       const bambuSerial = String(args?.bambu_serial || DEFAULT_BAMBU_SERIAL);
       const bambuToken = String(args?.bambu_token || DEFAULT_BAMBU_TOKEN);
+      const requestedTemplateDir =
+        typeof args?.template_dir === "string" && args.template_dir.trim().length > 0
+          ? String(args.template_dir)
+          : undefined;
+      const requestedTemplateName =
+        typeof args?.template_name === "string" ? String(args.template_name) : undefined;
+      const resolveTemplatePathFromName = (sourceTypes?: TemplateSourceType[]) =>
+        this.resolveTemplatePath(requestedTemplateName, requestedTemplateDir, sourceTypes);
+      const explicitTemplatePath = String(args?.template_3mf_path || DEFAULT_TEMPLATE_3MF_PATH);
+
       try {
         let result;
 
@@ -1195,6 +2617,75 @@ class BambuPrinterMCPServer {
             result = await this.bambu.getStatus(host, bambuSerial, bambuToken);
             break;
 
+          case "get_printer_filaments": {
+            const requestedModel = (String(args?.bambu_model ?? DEFAULT_BAMBU_MODEL ?? "")).trim().toLowerCase();
+            const normalizedModel = requestedModel ? validateBambuModel(requestedModel) : undefined;
+            const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+            result = await this.getResolvedPrinterFilamentInventory(
+              host,
+              bambuSerial,
+              bambuToken,
+              normalizedModel,
+              nozzleDiam
+            );
+            break;
+          }
+
+          case "resolve_3mf_ams_slots": {
+            if (!args?.three_mf_path) {
+              throw new Error("Missing required parameter: three_mf_path");
+            }
+            const requestedModel = (String(args?.bambu_model ?? DEFAULT_BAMBU_MODEL ?? "")).trim().toLowerCase();
+            const normalizedModel = requestedModel ? validateBambuModel(requestedModel) : undefined;
+            const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+            const requirements = await analyze3MFAmsRequirements(
+              String(args.three_mf_path),
+              args?.plate_index !== undefined ? Number(args.plate_index) : 0
+            );
+            const inventory = await this.getResolvedPrinterFilamentInventory(
+              host,
+              bambuSerial,
+              bambuToken,
+              normalizedModel,
+              nozzleDiam
+            );
+            const resolved = resolveAmsSlotsFromRequirements(requirements, inventory);
+            result = {
+              status: resolved.missing.length === 0 ? "matched" : "missing",
+              requirements,
+              ams_slots: resolved.ams_slots,
+              matches: resolved.matches,
+              missing: resolved.missing,
+            };
+            break;
+          }
+
+          case "list_3mf_plate_objects": {
+            if (!args?.three_mf_path) {
+              throw new Error("Missing required parameter: three_mf_path");
+            }
+            result = await analyze3MFPlateObjects(
+              String(args.three_mf_path),
+              args?.plate_index !== undefined ? Number(args.plate_index) : 0
+            );
+            break;
+          }
+
+          case "list_templates":
+            result = this.listTemplateRegistry(requestedTemplateDir);
+            break;
+
+          case "save_template":
+            if (!args?.source_path) {
+              throw new Error("Missing required parameter: source_path");
+            }
+            result = this.saveTemplate(
+              String(args.source_path),
+              typeof args?.template_name === "string" ? String(args.template_name) : undefined,
+              requestedTemplateDir
+            );
+            break;
+
           case "list_printer_files":
             result = await this.bambu.getFiles(host, bambuSerial, bambuToken);
             break;
@@ -1235,6 +2726,31 @@ class BambuPrinterMCPServer {
             break;
           }
 
+          case "camera_snapshot": {
+            const snapshotModel = (args?.bambu_model as string | undefined) ?? process.env.BAMBU_MODEL ?? process.env.BAMBU_PRINTER_MODEL;
+            result = await this.bambu.cameraSnapshot(host, bambuSerial, bambuToken, {
+              savePath: args?.save_path ? String(args.save_path) : undefined,
+              timeoutMs: args?.timeout_ms !== undefined ? Number(args.timeout_ms) : undefined,
+              bambuModel: snapshotModel ? String(snapshotModel) : undefined,
+              experimental: Boolean(args?.experimental),
+              ffmpegPath: args?.ffmpeg_path ? String(args.ffmpeg_path) : undefined,
+            });
+            break;
+          }
+
+          case "delete_printer_file":
+            if (!args?.filename) {
+              throw new Error("Missing required parameter: filename");
+            }
+            result = await this.bambu.deleteFile(
+              host,
+              bambuSerial,
+              bambuToken,
+              String(args.filename),
+              args.confirm
+            );
+            break;
+
           case "upload_gcode": {
             if (!args?.filename) {
               throw new Error("Missing required parameter: filename");
@@ -1279,6 +2795,45 @@ class BambuPrinterMCPServer {
             result = await this.bambu.cancelJob(host, bambuSerial, bambuToken);
             break;
 
+          case "pause_print":
+            result = await this.bambu.pauseJob(host, bambuSerial, bambuToken);
+            break;
+
+          case "resume_print":
+            result = await this.bambu.resumeJob(host, bambuSerial, bambuToken);
+            break;
+
+          case "clear_hms_errors":
+            result = await this.bambu.clearHmsErrors(host, bambuSerial, bambuToken);
+            break;
+
+          case "set_print_speed":
+            if (!args?.mode) {
+              throw new Error("Missing required parameter: mode");
+            }
+            result = await this.bambu.setPrintSpeed(host, bambuSerial, bambuToken, String(args.mode));
+            break;
+
+          case "set_airduct_mode":
+            if (!args?.mode) {
+              throw new Error("Missing required parameter: mode");
+            }
+            result = await this.bambu.setAirductMode(host, bambuSerial, bambuToken, String(args.mode));
+            break;
+
+          case "reread_ams_rfid":
+            if (args?.ams_id === undefined || args?.slot_id === undefined) {
+              throw new Error("Missing required parameters: ams_id and slot_id");
+            }
+            result = await this.bambu.rereadAmsRfid(
+              host,
+              bambuSerial,
+              bambuToken,
+              Number(args.ams_id),
+              Number(args.slot_id)
+            );
+            break;
+
           case "set_temperature":
             if (!args?.component || args?.temperature === undefined) {
               throw new Error("Missing required parameters: component and temperature");
@@ -1289,6 +2844,57 @@ class BambuPrinterMCPServer {
             );
             break;
 
+          case "set_fan_speed":
+            if (!args?.fan || args?.speed === undefined) {
+              throw new Error("Missing required parameters: fan and speed");
+            }
+            result = await this.bambu.setFanSpeed(
+              host,
+              bambuSerial,
+              bambuToken,
+              String(args.fan),
+              Number(args.speed)
+            );
+            break;
+
+          case "set_light":
+            if (!args?.light || !args?.mode) {
+              throw new Error("Missing required parameters: light and mode");
+            }
+            result = await this.bambu.setLight(
+              host,
+              bambuSerial,
+              bambuToken,
+              String(args.light),
+              String(args.mode)
+            );
+            break;
+
+          case "skip_objects":
+            if (!Array.isArray(args?.object_ids)) {
+              throw new Error("Missing required parameter: object_ids");
+            }
+            result = await this.bambu.skipObjects(
+              host,
+              bambuSerial,
+              bambuToken,
+              args.object_ids.map((id: unknown) => Number(id))
+            );
+            break;
+
+          case "set_ams_drying":
+            if (!args?.action || args?.ams_id === undefined) {
+              throw new Error("Missing required parameters: action and ams_id");
+            }
+            result = await this.bambu.setAmsDrying(
+              host,
+              bambuSerial,
+              bambuToken,
+              String(args.action),
+              Number(args.ams_id)
+            );
+            break;
+
           case "extend_stl_base":
             if (!args?.stl_path || args?.extension_height === undefined) {
               throw new Error("Missing required parameters: stl_path and extension_height");
@@ -1333,13 +2939,113 @@ class BambuPrinterMCPServer {
             result = await this.stlManipulator.getSTLInfo(String(args.stl_path));
             break;
 
+          case "get_slice_settings":
+            if (!args?.source_path && !args?.template_name) {
+              throw new Error("Missing required parameter: source_path or template_name");
+            }
+            result = await this.inspectSliceSettings(
+              String(args?.source_path || resolveTemplatePathFromName(["3mf", "json", "config"]))
+            );
+            break;
+
+          case "slice_with_template": {
+            if (!args?.stl_path) {
+              throw new Error("Missing required parameter: stl_path");
+            }
+            if (!args?.template_name) {
+              throw new Error("Missing required parameter: template_name");
+            }
+            const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args as Record<string, unknown> | undefined);
+            const sliceModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
+            const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+            const activeSlicerProfile = await resolveTemplateFirstSlicerProfilePath(
+              args,
+              slicerProfile || undefined,
+              resolveTemplatePathFromName(["json", "config", "3mf"]) || explicitTemplatePath || undefined,
+              TEMP_DIR
+            );
+            const explicitSlicerProfile = hasExplicitSlicerProfile(args);
+            const printerPreset = BAMBU_MODEL_PRESETS[sliceModel]?.(nozzleDiam);
+
+            const sliceBambuOptions: BambuSliceOptions = {};
+            if (args?.uptodate !== undefined) sliceBambuOptions.uptodate = Boolean(args.uptodate);
+            if (args?.repetitions !== undefined) sliceBambuOptions.repetitions = Number(args.repetitions);
+            if (args?.orient !== undefined) sliceBambuOptions.orient = Boolean(args.orient);
+            if (args?.arrange !== undefined) sliceBambuOptions.arrange = Boolean(args.arrange);
+            if (args?.ensure_on_bed !== undefined) sliceBambuOptions.ensureOnBed = Boolean(args.ensure_on_bed);
+            if (args?.clone_objects !== undefined) sliceBambuOptions.cloneObjects = String(args.clone_objects);
+            if (args?.skip_objects !== undefined) sliceBambuOptions.skipObjects = String(args.skip_objects);
+            if (
+              args?.load_filaments !== undefined &&
+              args?.filament_profile !== undefined &&
+              String(args.load_filaments) !== String(args.filament_profile)
+            ) {
+              throw new Error("Provide either load_filaments or filament_profile, not conflicting values.");
+            }
+            if (args?.load_filaments !== undefined) {
+              sliceBambuOptions.loadFilaments = String(args.load_filaments);
+            } else if (args?.filament_profile !== undefined) {
+              sliceBambuOptions.loadFilaments = String(args.filament_profile);
+            }
+            if (args?.load_filament_ids !== undefined) sliceBambuOptions.loadFilamentIds = String(args.load_filament_ids);
+            sliceBambuOptions.bedType = resolveBambuStudioCliBedType(args?.bed_type as string | undefined);
+            if (args?.enable_timelapse !== undefined) sliceBambuOptions.enableTimelapse = Boolean(args.enable_timelapse);
+            if (args?.allow_mix_temp !== undefined) sliceBambuOptions.allowMixTemp = Boolean(args.allow_mix_temp);
+            if (args?.scale !== undefined) sliceBambuOptions.scale = Number(args.scale);
+            if (args?.rotate !== undefined) sliceBambuOptions.rotate = Number(args.rotate);
+            if (args?.rotate_x !== undefined) sliceBambuOptions.rotateX = Number(args.rotate_x);
+            if (args?.rotate_y !== undefined) sliceBambuOptions.rotateY = Number(args.rotate_y);
+            if (args?.min_save !== undefined) sliceBambuOptions.minSave = Boolean(args.min_save);
+            if (args?.skip_modified_gcodes !== undefined) sliceBambuOptions.skipModifiedGcodes = Boolean(args.skip_modified_gcodes);
+            if (args?.slice_plate !== undefined) sliceBambuOptions.slicePlate = Number(args.slice_plate);
+            const usePrinterFilaments =
+              args?.use_printer_filaments !== undefined ? Boolean(args.use_printer_filaments) : true;
+            if (
+              usePrinterFilaments &&
+              !explicitSlicerProfile &&
+              !sliceBambuOptions.loadFilaments &&
+              bambuSerial &&
+              bambuToken
+            ) {
+              try {
+                const liveFilaments = await this.getResolvedPrinterFilamentInventory(
+                  host,
+                  bambuSerial,
+                  bambuToken,
+                  sliceModel,
+                  nozzleDiam
+                );
+                if (liveFilaments.recommended?.load_filaments) {
+                  sliceBambuOptions.loadFilaments = liveFilaments.recommended.load_filaments;
+                }
+              } catch (filamentError) {
+                console.warn("Could not resolve live printer filaments for slicing:", filamentError);
+              }
+            }
+
+            result = await this.stlManipulator.sliceSTL(
+              String(args.stl_path), slicerType, slicerPath,
+              activeSlicerProfile,
+              undefined,
+              printerPreset,
+              sliceBambuOptions
+            );
+            break;
+          }
+
           case "slice_stl": {
             if (!args?.stl_path) {
               throw new Error("Missing required parameter: stl_path");
             }
-            const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args);
+            const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args as Record<string, unknown> | undefined);
             const sliceModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
             const nozzleDiam = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+            const activeSlicerProfile = await resolveSlicerProfilePath(
+              slicerProfile || undefined,
+              resolveTemplatePathFromName(["json", "config", "3mf"]) || explicitTemplatePath || undefined,
+              TEMP_DIR
+            );
+            const explicitSlicerProfile = hasExplicitSlicerProfile(args);
             // Resolve printer preset for BambuStudio slicer
             const printerPreset = BAMBU_MODEL_PRESETS[sliceModel]?.(nozzleDiam);
 
@@ -1364,6 +3070,7 @@ class BambuPrinterMCPServer {
               sliceBambuOptions.loadFilaments = String(args.filament_profile);
             }
             if (args?.load_filament_ids !== undefined) sliceBambuOptions.loadFilamentIds = String(args.load_filament_ids);
+            sliceBambuOptions.bedType = resolveBambuStudioCliBedType(args?.bed_type as string | undefined);
             if (args?.enable_timelapse !== undefined) sliceBambuOptions.enableTimelapse = Boolean(args.enable_timelapse);
             if (args?.allow_mix_temp !== undefined) sliceBambuOptions.allowMixTemp = Boolean(args.allow_mix_temp);
             if (args?.scale !== undefined) sliceBambuOptions.scale = Number(args.scale);
@@ -1373,10 +3080,34 @@ class BambuPrinterMCPServer {
             if (args?.min_save !== undefined) sliceBambuOptions.minSave = Boolean(args.min_save);
             if (args?.skip_modified_gcodes !== undefined) sliceBambuOptions.skipModifiedGcodes = Boolean(args.skip_modified_gcodes);
             if (args?.slice_plate !== undefined) sliceBambuOptions.slicePlate = Number(args.slice_plate);
+            const usePrinterFilaments =
+              args?.use_printer_filaments !== undefined ? Boolean(args.use_printer_filaments) : true;
+            if (
+              usePrinterFilaments &&
+              !explicitSlicerProfile &&
+              !sliceBambuOptions.loadFilaments &&
+              bambuSerial &&
+              bambuToken
+            ) {
+              try {
+                const liveFilaments = await this.getResolvedPrinterFilamentInventory(
+                  host,
+                  bambuSerial,
+                  bambuToken,
+                  sliceModel,
+                  nozzleDiam
+                );
+                if (liveFilaments.recommended?.load_filaments) {
+                  sliceBambuOptions.loadFilaments = liveFilaments.recommended.load_filaments;
+                }
+              } catch (filamentError) {
+                console.warn("Could not resolve live printer filaments for slicing:", filamentError);
+              }
+            }
 
             result = await this.stlManipulator.sliceSTL(
               String(args.stl_path), slicerType, slicerPath,
-              slicerProfile || undefined,
+              activeSlicerProfile,
               undefined, // progressCallback
               printerPreset,
               sliceBambuOptions
@@ -1388,20 +3119,25 @@ class BambuPrinterMCPServer {
             if (!args?.three_mf_path) {
               throw new Error("Missing required parameter: three_mf_path");
             }
-
             if (String(args?.connection_mode || "lan_mqtt_ftps") === "bambu_network") {
               result = await this.print3mfViaBambuNetwork(args as Record<string, any>, host, bambuSerial, bambuToken);
               break;
             }
-
             if (!bambuSerial || !bambuToken) {
               throw new Error("Bambu serial number and access token are required for print_3mf.");
             }
 
-            const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args);
+            const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args as Record<string, unknown> | undefined);
             const printModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
             const printBedType = resolveBedType(args?.bed_type as string | undefined);
             const printNozzle = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+            const activeSlicerProfile = await resolveTemplateFirstSlicerProfilePath(
+              args,
+              slicerProfile || undefined,
+              resolveTemplatePathFromName(["json", "config", "3mf"]) || explicitTemplatePath || undefined,
+              TEMP_DIR
+            );
+            const explicitSlicerProfile = hasExplicitSlicerProfile(args);
             const printPreset = BAMBU_MODEL_PRESETS[printModel]?.(printNozzle);
             const plateIndex = args?.plate_index !== undefined ? Number(args.plate_index) : 0;
 
@@ -1420,15 +3156,37 @@ class BambuPrinterMCPServer {
                 f => f.match(/Metadata\/plate_\d+\.gcode/i) || f.endsWith('.gcode')
               );
               if (!hasGcode) {
-                console.log(`3MF has no gcode - auto-slicing with ${slicerType} for ${printModel}`);
+                if (printBedType === "supertack_plate") {
+                  throw new Error(
+                    'BambuStudio CLI SuperTack bed type is not verified; use a pre-sliced 3MF for SuperTack or choose textured_plate, cool_plate, engineering_plate, or hot_plate.'
+                  );
+                }
+                console.log(`3MF has no gcode — auto-slicing with ${slicerType} for ${printModel}`);
                 const autoSliceOptions: BambuSliceOptions = {
                   uptodate: true,
                   ensureOnBed: true,
                   minSave: true,
                   skipModifiedGcodes: true,
+                  bedType: printBedType,
                 };
+                if (!explicitSlicerProfile) {
+                  try {
+                    const liveFilaments = await this.getResolvedPrinterFilamentInventory(
+                      host,
+                      bambuSerial,
+                      bambuToken,
+                      printModel,
+                      printNozzle
+                    );
+                    if (liveFilaments.recommended?.load_filaments) {
+                      autoSliceOptions.loadFilaments = liveFilaments.recommended.load_filaments;
+                    }
+                  } catch (filamentError) {
+                    console.warn("Could not resolve live printer filaments for auto-slicing:", filamentError);
+                  }
+                }
                 threeMFPath = await this.stlManipulator.sliceSTL(
-                  threeMFPath, slicerType, slicerPath, slicerProfile || undefined,
+                  threeMFPath, slicerType, slicerPath, activeSlicerProfile,
                   undefined, // progressCallback
                   printPreset,
                   autoSliceOptions
@@ -1436,43 +3194,93 @@ class BambuPrinterMCPServer {
                 console.log("Auto-sliced to: " + threeMFPath);
               }
             } catch (sliceCheckErr: any) {
+              if (String(sliceCheckErr?.message || "").includes("SuperTack")) {
+                throw sliceCheckErr;
+              }
               console.warn("Could not check/slice 3MF, proceeding with original:", sliceCheckErr.message);
             }
 
             const parsed3MFData = await parse3MF(threeMFPath);
+            const isH2Print = printModel === "h2s" || printModel === "h2d";
             let parsedAmsMapping: number[] | undefined;
-            if (parsed3MFData.slicerConfig?.ams_mapping) {
-              const slots = Object.values(parsed3MFData.slicerConfig.ams_mapping)
-                .filter(v => typeof v === 'number') as number[];
+            if (!isH2Print && parsed3MFData.slicerConfig?.ams_mapping) {
+              const slots = normalizeAmsMappingObject(parsed3MFData.slicerConfig.ams_mapping as Record<string, unknown>);
               if (slots.length > 0) {
-                parsedAmsMapping = slots.sort((a, b) => a - b);
+                parsedAmsMapping = slots;
               }
             }
 
             let finalAmsMapping = parsedAmsMapping;
-            const explicitUseAMS = args?.use_ams !== undefined;
-            let useAMS = explicitUseAMS ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
+            let finalAmsSlots: number[] | undefined;
+            let useAMS = args?.use_ams !== undefined ? Boolean(args.use_ams) : (!!finalAmsMapping && finalAmsMapping.length > 0);
+            const hasUserAmsMapping = hasAmsMappingInput(args?.ams_mapping);
+            const hasUserAmsSlots = Array.isArray(args?.ams_slots);
 
-            if (args?.ams_mapping) {
+            if (hasUserAmsMapping) {
               let userMappingOverride: number[] | undefined;
               if (Array.isArray(args.ams_mapping)) {
-                userMappingOverride = args.ams_mapping.filter((v: any) => typeof v === 'number');
-              } else if (typeof args.ams_mapping === 'object') {
-                userMappingOverride = Object.values(args.ams_mapping)
-                  .filter((v: any) => typeof v === 'number')
-                  .sort((a: any, b: any) => a - b) as number[];
+                userMappingOverride = args.ams_mapping.map((v: unknown, i: number) =>
+                  normalizeBridgeAmsTrayValue(v, `ams_mapping[${i}]`)
+                );
+              } else if (args.ams_mapping && typeof args.ams_mapping === 'object') {
+                userMappingOverride = normalizeAmsMappingObject(args.ams_mapping as Record<string, unknown>);
               }
               if (userMappingOverride && userMappingOverride.length > 0) {
                 finalAmsMapping = userMappingOverride;
                 useAMS = true;
               }
             }
+            if (hasUserAmsSlots) {
+              const userSlots = (args.ams_slots as unknown[]).filter((v: any) => typeof v === 'number');
+              if (userSlots.length > 0) {
+                finalAmsSlots = userSlots;
+                finalAmsMapping = undefined;
+                useAMS = true;
+              }
+            }
+            if (!hasUserAmsMapping && !hasUserAmsSlots && args?.auto_match_ams === true && args?.use_ams !== false) {
+              const requirements = await analyze3MFAmsRequirements(threeMFPath, plateIndex);
+              const inventory = await this.getResolvedPrinterFilamentInventory(
+                host,
+                bambuSerial,
+                bambuToken,
+                printModel,
+                printNozzle
+              );
+              const resolved = resolveAmsSlotsFromRequirements(requirements, inventory);
+              if (resolved.missing.length > 0) {
+                throw new Error(
+                  `auto_match_ams could not find loaded AMS trays for: ${resolved.missing
+                    .map((missing) => missing.tray_info_idx || `filament position ${missing.filament_position}`)
+                    .join(", ")}`
+                );
+              }
+              finalAmsMapping = undefined;
+              finalAmsSlots = resolved.ams_slots;
+              useAMS = finalAmsSlots.length > 0;
+            }
+            if (
+              isH2Print &&
+              !hasUserAmsMapping &&
+              !hasUserAmsSlots &&
+              args?.auto_match_ams !== true &&
+              (!finalAmsMapping || finalAmsMapping.length === 0) &&
+              (!finalAmsSlots || finalAmsSlots.length === 0)
+            ) {
+              const requirements = await analyze3MFAmsRequirements(threeMFPath, plateIndex);
+              if (requirements.usedFilamentPositions.length > 0) {
+                throw new Error(
+                  `H2 ${printModel.toUpperCase()} pre-sliced jobs with declared filaments require ams_slots, ams_mapping, or auto_match_ams: true. Plate uses project filament positions ${JSON.stringify(requirements.usedFilamentPositions)}; pass one physical tray per used filament, for example ams_slots: [0] for AMS 0 slot 0 or [1] for AMS 0 slot 1.`
+                );
+              }
+            }
 
             if (args?.use_ams === false) {
               finalAmsMapping = undefined;
+              finalAmsSlots = undefined;
               useAMS = false;
             }
-            if ((!finalAmsMapping || finalAmsMapping.length === 0) && !explicitUseAMS) {
+            if ((!finalAmsMapping || finalAmsMapping.length === 0) && (!finalAmsSlots || finalAmsSlots.length === 0)) {
               useAMS = false;
             }
 
@@ -1485,6 +3293,7 @@ class BambuPrinterMCPServer {
               plateIndex,
               useAMS: useAMS,
               amsMapping: finalAmsMapping,
+              amsSlots: finalAmsSlots,
               bedType: printBedType,
               bedLeveling: args?.bed_leveling !== undefined ? Boolean(args.bed_leveling) : undefined,
               flowCalibration: args?.flow_calibration !== undefined ? Boolean(args.flow_calibration) : undefined,
@@ -1496,6 +3305,92 @@ class BambuPrinterMCPServer {
             break;
           }
 
+          case "print_collar_charm": {
+            const resolvedTemplateSourcePath = resolveTemplatePathFromName(["3mf"]);
+            const resolvedSourcePath = String(resolvedTemplateSourcePath || args?.source_path || "");
+            if (!resolvedSourcePath) {
+              throw new Error("Missing required parameter: source_path or template_name");
+            }
+            if (!bambuSerial || !bambuToken) {
+              throw new Error("Bambu serial number and access token are required for print_collar_charm.");
+            }
+
+            const { slicerType, slicerPath, slicerProfile } = resolveSlicerConfig(args as Record<string, unknown> | undefined);
+            const printModel = await this.resolveBambuModel(args?.bambu_model as string | undefined);
+            const printBedType = resolveBedType(args?.bed_type as string | undefined);
+            const printNozzle = String(args?.nozzle_diameter || DEFAULT_NOZZLE_DIAMETER);
+            const activeSlicerProfile = await resolveTemplateFirstSlicerProfilePath(
+              args,
+              slicerProfile || undefined,
+              resolvedTemplateSourcePath || explicitTemplatePath || undefined,
+              TEMP_DIR
+            );
+
+            const preparedThreeMFPath = await this.resolveCollarCharmPrepared3MF(
+              resolvedSourcePath,
+              resolvedTemplateSourcePath || explicitTemplatePath || undefined,
+              slicerType,
+              slicerPath,
+              activeSlicerProfile || undefined,
+              printModel,
+              printNozzle,
+              printBedType,
+              host,
+              bambuSerial,
+              bambuToken
+            );
+
+            const collarAnalysis = await analyzeCollarCharm3MF(preparedThreeMFPath, 0);
+            const inventory = await this.preflightCollarCharmPolicy(
+              host,
+              bambuSerial,
+              bambuToken,
+              printModel,
+              printNozzle
+            );
+
+            const projectName = path.basename(preparedThreeMFPath).replace(/\.3mf$/i, '');
+            result = await this.bambu.print3mf(host, bambuSerial, bambuToken, {
+              projectName,
+              filePath: preparedThreeMFPath,
+              plateIndex: collarAnalysis.plateIndex,
+              useAMS: true,
+              amsSlots: collarAnalysis.amsSlots,
+              bedType: printBedType,
+              bedLeveling: args?.bed_leveling !== undefined ? Boolean(args.bed_leveling) : true,
+              flowCalibration: args?.flow_calibration !== undefined ? Boolean(args.flow_calibration) : true,
+              vibrationCalibration: args?.vibration_calibration !== undefined ? Boolean(args.vibration_calibration) : true,
+              timelapse: args?.timelapse !== undefined ? Boolean(args.timelapse) : false,
+            });
+
+            result = {
+              ...result,
+              source_path: resolvedSourcePath,
+              prepared_three_mf_path: preparedThreeMFPath,
+              tray_policy: {
+                inner: {
+                  color: COLLAR_CHARM_POLICY.colors.inner,
+                  absolute_tray: COLLAR_CHARM_POLICY.amsSlots.inner,
+                },
+                outer: {
+                  color: COLLAR_CHARM_POLICY.colors.outer,
+                  absolute_tray: COLLAR_CHARM_POLICY.amsSlots.outer,
+                },
+              },
+              collar_roles: collarAnalysis.roles,
+              inventory_slots_checked: inventory.trays
+                .filter((tray) => tray.slot === COLLAR_CHARM_POLICY.amsSlots.inner || tray.slot === COLLAR_CHARM_POLICY.amsSlots.outer)
+                .map((tray) => ({
+                  slot: tray.slot,
+                  loaded: tray.loaded,
+                  tray_color: tray.tray_color,
+                  tray_type: tray.tray_type,
+                  tray_info_idx: tray.tray_info_idx,
+                })),
+            };
+            break;
+          }
+
           case "merge_vertices":
             if (!args?.stl_path) throw new Error("Missing required parameter: stl_path");
             result = await this.stlManipulator.mergeVertices(